/*

* Copyright (c) 2002-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:   SUPL protocol manager implementation.i.e. OMA SUPL implementation 

*

*/

#include <centralrepository.h>

#include <ecom/ecom.h> 

#include <flogger.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include "epos_csuplsessionbase.h"

#include "epos_comasuplasnbase.h"

#include "epos_comasuplasnmessagebase.h"

#include "epos_csuplprotocolmanagerbase.h"

#include "lbs/epos_comasuplposhandlerbase.h"

#include "epos_suplconstants.h"

#include "epos_csuplsettings.h"

#include "epos_csuplsettingsinternal.h"

#include "epos_suplterminalconstants.h"

#include "epos_comasuplprotocolmanager.h"

#include "epos_csuplcommunicationmanager.h"

#include "epos_comasuplsettings.h"

#include "epos_omasuplconstants.h"

#include "epos_comasupltrace.h"

#include "epos_comasuplcommonconfig.h"

#include "epos_comasuplinitilizerequestor.h"

_LIT(KTraceFileName,"SUPL_OMA_PH::EPos_COMASUPLProtocolManager.cpp");

const TInt KMaxIMSILen = 20;

// -----------------------------------------------------------------------------

// ResetAndDestroy()

// Resets & destroys array if leave occurs

// -----------------------------------------------------------------------------

void ResetAndDestroy(TAny* aArray)

	{

	((RImplInfoPtrArray*)aArray)->ResetAndDestroy();

	}

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

// Create instance of concrete ECOM interface implementation

EXPORT_C COMASUPLProtocolManager* COMASUPLProtocolManager::NewL()

	{

	COMASUPLProtocolManager* self = new(ELeave) COMASUPLProtocolManager();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	} 

// Destructor.

EXPORT_C COMASUPLProtocolManager::~COMASUPLProtocolManager()

	{

    if( !isPH2Shared )

        {

        delete iOMASuplProtocolHandler1;

        }

    delete iOMASuplProtocolHandler2;

    iOMASuplProtocolHandler2 = NULL;

	delete iCommonConfig;

	iCommonConfig = NULL;

	delete iTrace;	

	iTrace = NULL;

	delete iOMASuplAsnHandlerBaseImpl;

	iOMASuplAsnHandlerBaseImpl = NULL;

	delete iOMASuplInitilizeRequestor;

	iOMASuplInitilizeRequestor=NULL;

	delete iOMASuplDeInitilizer;

	iOMASuplDeInitilizer = NULL;

	}

// Constructor

EXPORT_C COMASUPLProtocolManager::COMASUPLProtocolManager() : 

										iTrace(NULL),  

                                        iInitilizationRequestStatus(NULL),

                                        iInitilizationRequestStatus2(NULL),

                                        iDeInitRequestStatus(NULL),

                                        iOMASuplInitilizeRequestor(NULL),

                                        iOMASuplProtocolHandler1(NULL),

                                        iOMASuplProtocolHandler2(NULL),

                                        iCommonConfig(NULL),

                                        iCommManager(NULL),

                                        iIsInitilized(EFalse),

                                        isPH2Shared(EFalse),

                                        iIsPhDeinitialized1(EFalse),

                                        iIsPhDeinitialized2(EFalse)

    {

	// no implementation required

	}

// Second phase construction.

void COMASUPLProtocolManager::ConstructL()

	{

    iTrace = COMASuplTrace::NewL();	

	LoadOMASUPLPluginsL();

	iTrace->Trace(_L("COMASUPLProtocolManager::ConstructL"), KTraceFileName, __LINE__);

	iCommonConfig = COMASuplCommonConfig::NewL();

	iOMASuplInitilizeRequestor = COMASuplInitilizeRequestor::NewL(

										iCommonConfig->iPosHandler,

										*this,

										iCommonConfig->iSuplSettings);

	iOMASuplDeInitilizer = COMASuplDeInitilizer::NewL(*this);

	TRAPD(err,iOMASuplAsnHandlerBaseImpl = COMASuplAsnHandlerBase::NewL(1));

    if( KErrNone != err )

        {

        TRAP(err,iOMASuplAsnHandlerBaseImpl = COMASuplAsnHandlerBase::NewL(2));

        }

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::CreateNewSessionL, 

// Creates new session 

// it transfers ownership to callee

// 

// -----------------------------------------------------------------------------

//    

EXPORT_C CSuplSessionBase* COMASUPLProtocolManager::CreateNewSessionL(

										CSUPLProtocolManagerBase::TSuplReqType aRequestType, 

										TInt aIpcSessionId, 

										RSuplTerminalSubSession::TSuplServiceType aSuplService)

	{

    if(!iIsInitilized) // if its not initilized, then leave with KErrSuplUnInitilized

	    User::LeaveIfError(KErrOMASuplUnInitilized);

    if( aSuplService == RSuplTerminalSubSession::ESUPL_1_0 )

	    {

        if(iOMASuplProtocolHandler1)

            {

            return iOMASuplProtocolHandler1->CreateNewSessionL(

            							aRequestType, 

            							aIpcSessionId, 

            							aSuplService);

            }

        return NULL;

	    }

	else if( aSuplService == RSuplTerminalSubSession::ESUPL_2_0 )

	    {

	    if(iOMASuplProtocolHandler2)

	        {

	        return iOMASuplProtocolHandler2->CreateNewSessionL(

	        							aRequestType, 

	        							aIpcSessionId, 

	        							aSuplService);

	        }

        return NULL;

	    }

	else

	    {

        return NULL;

	    }

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::InitializeL 

// Does the connect to ETel. 

// Intilize POS if present 

// 

// -----------------------------------------------------------------------------

//    

EXPORT_C  void COMASUPLProtocolManager::InitializeL(

										CSuplCommunicationManager* aCommManager,

										TRequestStatus& aInitilizationRequestStatus)

	{

	iInitilizationRequestStatus = &aInitilizationRequestStatus;

    *iInitilizationRequestStatus = KRequestPending;

	if(iIsInitilized) 

		{

		CompleteInitilization(KErrNone);

		return;	

		}

    iCommManager = aCommManager;			

	iIsInitilized = EFalse;		    

	if(!iCommManager) 

		{

		CompleteInitilization(KErrArgument);

		return;	

		}

	iOMASuplInitilizeRequestor->DoInitilizationL();

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::CancelInitialize 

// Cancel Initilization of Protocol manager

// 

// -----------------------------------------------------------------------------

//

EXPORT_C  void COMASUPLProtocolManager::CancelInitialize() 

	{

	iTrace->Trace(_L("COMASUPLProtocolManager::CancelInitialize"), 

										KTraceFileName, __LINE__);

	CompleteInitilization(KErrCancel);

	iOMASuplInitilizeRequestor->Cancel();		

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::RunSessionL

// Starts the SUPL Sesssion for Terminal Initiated Location Request

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void COMASUPLProtocolManager::RunSessionL(

											CSuplSessionBase *const  aSuplSession,

											TRequestStatus& aStatus,

											const TDesC& aHslpAddress, 

											TBool aFallBack,

											TBool aFirstReq,

											TInt aAllowedCapabilities,

											TInt aRequestID)

	{

	iTrace->Trace(_L("COMASUPLProtocolManager::RunSessionL"), KTraceFileName, __LINE__);

	aStatus = KRequestPending;

	TRequestStatus *status = &aStatus; 

	if( iIsInitilized && iOMASuplProtocolHandler1 )

		{

		iOMASuplProtocolHandler1->RunSessionL(      

											aSuplSession,

                                            aStatus,

                                            aHslpAddress,

                                            aFallBack,

                                            aFirstReq,

                                            aAllowedCapabilities,

                                            aRequestID);

		}    

	else

	    {

	    User::RequestComplete(status,KErrOMASuplUnInitilized); 

	    }

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::RunSessionL

// Starts the SUPL Sesssion for Terminal Initiated Location Request,with QoP support

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void COMASUPLProtocolManager::RunSessionL(

                            CSuplSessionBase *const aSuplSession,

                            TRequestStatus& aStatus,

                            const TDesC& aHslpAddress, 

                            TBool aFallBack,

                            TBool aFirstReq,

  							TInt aAllowedCapabilities,

  							TSuplTerminalQop& aQop, 

  							TInt aRequestID)

	{

	iTrace->Trace(_L("COMASUPLProtocolManager::RunSessionL"), KTraceFileName, __LINE__);

	aStatus = KRequestPending;

	TRequestStatus *status = &aStatus; 

    if( iIsInitilized && iOMASuplProtocolHandler1 )

        {

        iOMASuplProtocolHandler1->RunSessionL(

                                            aSuplSession,

                                            aStatus,

                                            aHslpAddress,

                                            aFallBack,

                                            aFirstReq,

                                            aAllowedCapabilities,

                                            aQop,

                                            aRequestID);

        }    

    else

        {

        User::RequestComplete(status,KErrOMASuplUnInitilized); 

        }

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::DestroySession

// Deletes specified session & removes from array.

// Returns System wide error,if any occurs

// -----------------------------------------------------------------------------

//

EXPORT_C TInt COMASUPLProtocolManager::DestroySession(CSuplSessionBase* aSuplSession)	

	{

	iTrace->Trace(_L("Start of COMASUPLProtocolManager::DestroySession"), KTraceFileName, __LINE__);

	// Forward to PH1 first

	TInt err = KErrNone;

	if(iOMASuplProtocolHandler1)

	    {

	    err = iOMASuplProtocolHandler1->DestroySession(aSuplSession);

	    }

	// If session is not found in PH1 then forward it to PH2 else just return the error 

	if( KErrArgument == err && iOMASuplProtocolHandler2)

        {

        return iOMASuplProtocolHandler2->DestroySession(aSuplSession);

        }

	return err;

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::HandlePacket

// Handles Supl packets ,  received from SLP

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void COMASUPLProtocolManager::HandlePacket(const TDesC8& aPacket, TUint aPortNum)

	{

	iTrace->Trace(_L("Start of COMASUPLProtocolManager::HandlePacket"), 

											KTraceFileName, __LINE__);

	TInt major;

	TInt errorCode = GetSuplVersion(major,aPacket);

	if(errorCode != KErrNone )		

		{			

		HandlePacketError(errorCode);

		return;

		} 

	if( major == 1 )

		{

		if(iOMASuplProtocolHandler1)

		    {

		    iOMASuplProtocolHandler1->HandlePacket(aPacket,aPortNum);

		    }

		}

	else 

		{

		if(iOMASuplProtocolHandler2)

            {

            iOMASuplProtocolHandler2->HandlePacket(aPacket,aPortNum);

            }	

		}			

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::HandlePacketError

// Handles Supl packet receiving errors

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void COMASUPLProtocolManager::HandlePacketError(TInt /*aError*/)

	{

	// Do nothing for now

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::CancelRunSession

// Cancels run session operation if its going on.

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void COMASUPLProtocolManager::CancelRunSession(CSuplSessionBase* aSuplSession)

	{

	// Log

	iTrace->Trace(_L("COMASUPLProtocolManager::CancelRunSession"), KTraceFileName, __LINE__);

	if(iOMASuplProtocolHandler1)

	    {

	    iOMASuplProtocolHandler1->CancelRunSession(aSuplSession);

	    }

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::CompleteInitilization

// Completes initilization AO with error or without error.

// 

// -----------------------------------------------------------------------------

//

void COMASUPLProtocolManager::CompleteInitilization(TInt aCompletionCode)

	{	

	if(iInitilizationRequestStatus)

		User::RequestComplete(iInitilizationRequestStatus,aCompletionCode);

	iTrace->Trace(_L("COMASUPLProtocolManager::InitializeL"), KTraceFileName, __LINE__);

	if(iOMASuplProtocolHandler1)

	    {

	    TRAP_IGNORE(iOMASuplProtocolHandler1->InitializeL(iCommManager,*iInitilizationRequestStatus2));

	    }

	if(iOMASuplProtocolHandler2)

	    {

	    TRAP_IGNORE(iOMASuplProtocolHandler2->InitializeL(iCommManager,*iInitilizationRequestStatus));

	    }

	iTrace->Trace(_L("InitializeL completed"), KTraceFileName, __LINE__);	

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::InitilizationCompletedL

// Informs to client about Initilization of POS ,thro' active object

// 

// -----------------------------------------------------------------------------

//

void COMASUPLProtocolManager::InitilizationCompletedL(TInt aError)

	{

	iTrace->Trace(_L("COMASUPLProtocolManager::InitilizationCompletedL Start"), 

													KTraceFileName, __LINE__);

	TInt networkMode  = GetNetworkModeL();

	if ( networkMode == ECoreAppUIsNetworkConnectionNotAllowed 

			&& aError == KErrGeneral)

		{

		aError = KErrNone;

		}

	if(aError == KErrNone)

		{   

		iCommonConfig->iIMSI.Close();

	    iCommonConfig->iIMSI.Create( KMaxIMSILen );

	    aError = iOMASuplInitilizeRequestor->GetIMSI( iCommonConfig->iIMSI );

	    if( aError == KErrNotSupported || aError == KErrNone 

	    					|| (networkMode == ECoreAppUIsNetworkConnectionNotAllowed 

	    						&& aError == KErrNotReady))

	        {

	        iIsInitilized = ETrue;	

	        aError = KErrNone;

	        }

		}

	TBuf<64> buf(_L("COMASUPLProtocolManager::InitilizationCompletedL Error : "));

	buf.AppendNum(aError);

	iTrace->Trace(buf,KTraceFileName, __LINE__);

	SetCommonConfig(iCommonConfig);

	CompleteInitilization(aError);

	iTrace->Trace(_L("COMASUPLProtocolManager::InitilizationCompletedL End"), 

						KTraceFileName, __LINE__);

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::HandleSuplMessageL

// Informs to client about Initilization of POS ,thro' active object

// 

// -----------------------------------------------------------------------------

//	

EXPORT_C void COMASUPLProtocolManager::HandleSuplMessageL(

											CSuplSessionBase *const aSuplSession,

											TRequestStatus& aStatus,HBufC8* aMessage)

	{

	iTrace->Trace(_L("COMASUPLProtocolManager::HandleSuplMessageL"), KTraceFileName, __LINE__);

	TRequestStatus* status =  &aStatus;

	if(!aMessage)

		{

		iTrace->Trace(_L("Received packet is Empty."), KTraceFileName, __LINE__);

		if(status)

			User::RequestComplete(status,KErrBadDescriptor);

		return;

		}

	TInt major = aSuplSession->GetSUPLVersion();	

	if( major == 1 )

		{

		if(iOMASuplProtocolHandler1)

		    {

		    iOMASuplProtocolHandler1->HandleSuplMessageL(aSuplSession,aStatus,aMessage);

		    }

		}

	else 

		{

		if(iOMASuplProtocolHandler2)

		    {

		    iOMASuplProtocolHandler2->HandleSuplMessageL(aSuplSession,aStatus,aMessage);

		    }

		}			

	}

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::DeInitialize

// 

// 

// -----------------------------------------------------------------------------

//

void COMASUPLProtocolManager::DeInitialize(TRequestStatus& aDeInitRequestStatus)

    {

	iTrace->Trace(_L("COMASUPLProtocolManager::DeInitialize"), KTraceFileName, __LINE__);

	iDeInitRequestStatus = &aDeInitRequestStatus;

	if(iOMASuplProtocolHandler1 && !iIsPhDeinitialized1)

	    {

	    iTrace->Trace(_L("COMASUPLProtocolManager::DeInitialize ph1 issued"), KTraceFileName, __LINE__);

	    iIsPhDeinitialized1 = ETrue;

	    iOMASuplDeInitilizer->Deinitialize(iOMASuplProtocolHandler1);

	    }

	else

		{

		iTrace->Trace(_L("COMASUPLProtocolManager::DeInitialize ph1 not present"), KTraceFileName, __LINE__);

		DeInitilizationCompletedL( KErrNotFound ); //ph1 is not present.

		}

    }            

// -----------------------------------------------------------------------------

// COMASUPLProtocolManager::CancelDeInitialize

// 

// 

// -----------------------------------------------------------------------------

//	

void COMASUPLProtocolManager::CancelDeInitialize()

    {

	iTrace->Trace(_L("COMASUPLProtocolManager::CancelDeInitialize"), KTraceFileName, __LINE__);

	if(iOMASuplProtocolHandler1 && iIsPhDeinitialized1 )

        {

        iTrace->Trace(_L("COMASUPLProtocolManager::CancelDeInitialize ph1 issued"), KTraceFileName, __LINE__);

        iOMASuplProtocolHandler1->CancelDeInitialize();