// Copyright (c) 2003-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:

//

/**

 @file CSelectionRequest.cpp

*/

#include <nifman.h>

#include <comms-infras/nifagt.h>

#include <es_connpref.h>

#include "CSelectionRequest.h"

#include "CNetworkController.h"

#include "NetConPanic.h"

#include "NetConLog.h"

#include "NetConError.h"

CSelectionRequest* CSelectionRequest::NewL(MNetConEnv* aController, MNetworkControllerObserver* aObserver, TConnStartType aStartType, const TConnPref& aPrefs, TInt aConnectionAttempt, TInt aLastConnectionError)

/**

Factory function

Creates a new CSelectionRequest object

@param aController pointer to the Network Controller

@param aObserver the object that initiated this request

@param aStartType how this request was initiated either Implicit(due to RSocket/RHostResolver calls) or Explicit(due to an RConnection call)

@param aPrefs connection preferences to be used when selecting an appropriate Agent

@param aConnectionAttempt indicates the current connection attempt

@param aLastConnectionError if this is not the first connection attempt then the error of the last attempt

@exception leaves if object cannot be constructed

@return the new CSelectionRequest object

*/

 	{

	CSelectionRequest* self = new(ELeave) CSelectionRequest(aController, aObserver, aStartType, aPrefs, aConnectionAttempt, aLastConnectionError);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CSelectionRequest::~CSelectionRequest()

/**

Destructor

*/

	{

	if(iOverrides)

		delete iOverrides;

	if(iAgentName)

		delete iAgentName;

	}

CSelectionRequest::CSelectionRequest(MNetConEnv* aController, MNetworkControllerObserver* aObserver, TConnStartType aStartType, const TConnPref& aPrefs, TInt aConnectionAttempt, TInt aLastConnectionError)

: CNetConRequestBase(aController, aObserver, NULL), iConnStartType(aStartType), iConnPrefs(aPrefs), iConnectionAttempt(aConnectionAttempt), iLastConnectionError(aLastConnectionError)

/**

Constructor

@param aDatabase pointer to the object used to access CommDb

@param aDialogPrc pointer to the object used to access the dialog processor

@param aController pointer to the Network Controller

@param aObserver the object that initiated this request

@param aStartType how this request was initiated either Implicit(due to RSocket/RHostResolver calls) or Explicit(due to an RConnection call)

@param aPrefs connection preferences to be used when selecting an appropriate Agent

@param aConnectionAttempt indicates the current connection attempt

@param aLastConnectionError if this is not the first connection attempt then the error of the last attempt

*/

	{ }

void CSelectionRequest::ConstructL()

/**

2nd phase of construction

@exception leaves if 2nd phase construction leaves

*/

	{

	CNetConRequestBase::ConstructL();

	// construct a HBufC in which to store the name of the agent

	const TUint8 KInitialAgentNameLength = 20;

	iAgentName = HBufC::NewL(KInitialAgentNameLength);

	_LIT(KUndefined, "Undefined");

	SetAgentNameL(KUndefined());

	}

void CSelectionRequest::SetAgentNameL(const TDesC& aName)

/**

Replace the value of iAgentName allocating more memory if needed

@param aName the new name of the Agent

@exception leaves with KErrNoMemory if allocation fails

*/

	{

	ASSERT(iAgentName);

	// see if we need to allocate more memory for the agent name

	if (aName.Length() > iAgentName->Length())

		{

		iAgentName = iAgentName->ReAllocL(aName.Length());

		}

	// replace agent name

	*iAgentName = aName;

	}

void CSelectionRequest::StartRequest()

/**

Start processing this request

*/

	{

	LOG (

		NetConLog::Printf(_L("\tRequest type = Selection"));

		NetConLog::Printf(_L("\tConnection attempt = %d"), iConnectionAttempt);

		NetConLog::Printf(_L("\tConnection type = %d"), iConnStartType);

		)

	// set overrides for this request in the databse

	TRAPD(err, iDatabase->SetOverridesL(iOverrides);

               iDatabase->RequestNotificationOfServiceChangeL(ipServiceChangeObserver));

	if(err!=KErrNone)

		{

		LOG( NetConLog::Printf(_L("\tError %d encountered during start of IAP selection routine - is CommDb setup correctly?"), err); )

		RequestComplete(err);

		return;

		}

	TRAP(err, StartSelectL());

	if(err!=KErrNone)

		{

		LOG( NetConLog::Printf(_L("\tError %d encountered during start of IAP selection routine - is CommDb setup correctly?"), err); )

		RequestComplete(err);

		}

	}

void CSelectionRequest::RequestComplete(TInt aError)

/**

Complete this request with a given error

@param aError the error with which to complete the request

*/

	{

	LOG( NetConLog::Printf(_L("\tRequest Complete with error %d"), aError); )

	iController->RequestComplete(this, aError);

	}

const TDesC& CSelectionRequest::AgentName() const

/**

Retrieves the name of the agent that was selected

*/

	{

	if(!iAgentName)

		{

		return KNullDesC();

		}

	else

		{

		return *iAgentName;

		}

	}

const TPckgBuf<TSoIfConnectionInfo>& CSelectionRequest::AgentConnectionInfo() const

/**

Retrieves the connection information of the agent that was selected

*/

	{

	return iAgentConnInfo;

	}

const TConnStartType& CSelectionRequest::ConnectionStartType() const

/**

@return the connection start type - i.e. either implicit or explicit

*/

	{

	return iConnStartType;

	}

const TConnPref& CSelectionRequest::ConnPrefs() const

/**

@return the connection preferences associated with this request

*/

	{

	return iConnPrefs;

	}

void CSelectionRequest::StartSelectL()

/**

Start the selection process

Read current connection preferences and settings from the database then start the selection process. 

@exception leaves if database access leaves

*/

 	{

	// clear any existing overrides in the database

	iDatabase->SetOverridesL(NULL);

	// check that we are within the maximum number of connection attempts specified by CommDb

	TInt maxConnectionAttempts = iDatabase->GetConnectionAttempts();

	User::LeaveIfError(maxConnectionAttempts);

	// allow the connection preferences to override the max number of connection attempts in CommDb

	if(iConnPrefs.ExtensionId() == TConnPref::EConnPrefCommDbMulti)

		{

		TInt preferences = TCommDbMultiConnPref::Cast(iConnPrefs).ConnectionAttempts();

		maxConnectionAttempts = preferences; 

		}

	if(iConnectionAttempt > maxConnectionAttempts)

		{

		LOG( NetConLog::Printf(_L("\tError - maximum number of connection attempts (%d) reached"), maxConnectionAttempts); )

		RequestComplete(KErrOverflow);

		return;

		}

	// extract a TCommDbConnPref from iConnPrefs

	TCommDbConnPref commDbPref;

	User::LeaveIfError(ExtractCommDbConnPref(iConnPrefs, commDbPref));

	// set connection attempt

	iSettings.iRank = iConnectionAttempt;

	// if direction is not specified then default to outgoing

	if(commDbPref.Direction() == ECommDbConnectionDirectionUnknown)

		{

		commDbPref.SetDirection(ECommDbConnectionDirectionOutgoing);

		}

	// extract connection direction

	iSettings.iDirection = commDbPref.Direction();

	TUint32 overidenIap = commDbPref.IapId();

	// Wnsure that a valid IAP exists in the 

	TUint32 preferredIap(overidenIap);

	LOG( NetConLog::Printf(_L("\tpreferredIap=%d"), preferredIap); )

	if (overidenIap == 0)

		{

		iDatabase->GetPreferedIapL(preferredIap, iSettings.iDirection, iSettings.iRank);

		LOG( NetConLog::Printf(_L("\tnew preferredIap=%d"), preferredIap); )

		}

	// If this IAP doesn't exist, we must prompt the user

	if((preferredIap == 0) || !iDatabase->DoesIapExistL(preferredIap))

		{

		LOG( NetConLog::Printf(_L("\tActive settings for IAP have been set to prompt, since the IAP doesn't exist"));)

		commDbPref.SetDialogPreference(ECommDbDialogPrefPrompt);

		// IAP is invalid, override it in the active settings to allow prompt to continue

		iDatabase->GetFirstValidIapL(preferredIap);

		commDbPref.SetIapId(preferredIap);

		}

	// convert the connection preferences into some appropriate override settings

	iOverrides = MapPrefsToOverridesL(commDbPref, iSettings);

	if(iOverrides)

		{

		//set these overrides in the database

		iDatabase->SetOverridesL(iOverrides);

		}

	iDatabase->GetCurrentSettingsL(iSettings, iSettings.iDirection, iSettings.iRank);

	if((iConnStartType == EConnStartImplicit) && iController->ImplicitConnectionAgentName())

		{

		// there is already an implicit connection - try to match the preferences

		TCommDbConnPref implicitPref;

		User::LeaveIfError(ExtractCommDbConnPref(iController->ImplicitConnectionPrefs(), implicitPref));

		if(commDbPref == implicitPref)

			{

			// This is an implicit request for an outgoing connection and there

			// has already been another implicit request - just return the name

			// of the existing agent

			LOG( NetConLog::Printf(_L("\tReturning existing agent for implicit connection: '%S'"), iController->ImplicitConnectionAgentName()); )

			SetAgentNameL(*iController->ImplicitConnectionAgentName());

			RequestComplete(KErrNone);

			}

		else

			{

			LOG( NetConLog::Printf(_L("\tImplicit connection already exists - cannot start a new one with conflicting preferences!")); )

			RequestComplete(KErrInUse);

			}

		return;

		}

	// store the completed preferences as iConnPrefs

	// this is so that if the CNetworkController asks for the prefs used for the

	// selected connection we will return the accurate prefs (with the default

	// values filled in)

	iConnPrefs = commDbPref;

	// for some reason we have to write these settings back to the database, otherwise

	// when dialog prompt is set to warn we get an error - why?

	iDatabase->SetCurrentSettingsL(iSettings);

	// note that we no-longer display the "Select Modem & Location" dialog boxes

	// since the IAP points to the modem and location

	// read service settings from database

	iDatabase->GetServiceSettingsL(iSettings);

	LOG (

		NetConLog::Printf(_L("\tPreferred Service Type = '%S'"), &iSettings.iServiceType);

		NetConLog::Printf(_L("\tPreferred Service Id = %d"), iSettings.iServiceId);

		NetConLog::Printf(_L("\tPreferred Bearer Set = %d"), iSettings.iBearerSet);

		)

	// check for bearer availability

	iDoBearerAvailability = !(iSettings.iDialogPref==ECommDbDialogPrefWarn || iSettings.iDialogPref==ECommDbDialogPrefDoNotPrompt);

	if (iDoBearerAvailability)

		{

		// Bearer availability check is only performed if prompting

		// It is only used to help populate the dialogue with available bearers

		//

		// Warning: that the results of the CheckBearerAvailability are 

		// only used in the case of ECommDbDialogPrefPromptIfWrongMode

		// so it might be possible to remove this check and speed things up

		// 

		LOG( NetConLog::Printf(_L("\tRequesting bearer availability")); )

		iController->CheckBearerAvailability(EFalse);  // EFalse indicates that this is not a reconnection

		}

	else

		{

		// Not prompting so do best effort and allow all bearers

		// Allow all bearers if bearer availability check is not done

		LOG( NetConLog::Printf(_L("\tSkipping bearer availability check")); )

		SetAvailableBearers(KCommDbBearerCSD | KCommDbBearerLAN | KCommDbBearerVirtual);

		}

	}

TInt CSelectionRequest::ExtractCommDbConnPref(const TConnPref& aBasePref, TCommDbConnPref& aCommDbPref)

/**

Extract a single TCommDbConnPref from the given TConnPref

@param aBasePref the TConnPref

@param aCommDbPref on return contains the TCommDbConnPref extracted from the TConnPref

@return KErrNone if the TCommDbConnPref could be extracted, otherwise KErrArgument

*/

	{

	TInt err(KErrNone);

	// if the TConnPref argument is a valid CommDb connection preference then cast it to one

	switch(aBasePref.ExtensionId())

		{

		case TConnPref::EConnPrefCommDb:

			// cast down to a TCommDbConnPref

			aCommDbPref = TCommDbConnPref::Cast(aBasePref);

			break;

		case TConnPref::EConnPrefCommDbMulti:

			{

			// cast down to a TCommDbMultiConnPref

			TCommDbMultiConnPref multiPrefs = TCommDbMultiConnPref::Cast(aBasePref);

			// check the number of connection attempts

			if(iConnectionAttempt > multiPrefs.ConnectionAttempts())

				{

				LOG( NetConLog::Printf(_L("\tError - maximum number of connection attempts (%d) reached"), multiPrefs.ConnectionAttempts()); )

				err = KErrOverflow;

				}

			else

				{

				// connection attempt is ok, try to retrieve the connection preference for this attempt

				err = multiPrefs.GetPreference(iConnectionAttempt, aCommDbPref);

				}

			break;

			}

		case TConnPref::EConnPrefSnap:

			err = KErrNotSupported;

			break;

		case TConnPref::EConnPrefIdList:

			{

			const TCommIdList& pref = static_cast<const TCommIdList&>(aBasePref);

			// check the number of connection attempts

			if(iConnectionAttempt > pref.Count())

				{

				LOG( NetConLog::Printf(_L("\tError - the last AP (%d) reached"), pref.Count()); )

				err = KErrOverflow;

				}

			else

				{

				// connection attempt is ok, try to retrieve the connection preference for this attempt

				TInt iap = pref.Get(iConnectionAttempt-1);

				aCommDbPref.SetIapId(iap);

				aCommDbPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

				//otherwise keep the default TCommDbConnPref class settings

				}

			break;

			}

		case TConnPref::EConnPrefUnknown:

			// a TConnPref - just ignore and use the default values from the connection preferences table

			break;

		default:

			// some sort of unrecognised connection preference type - error the caller

			err = KErrArgument;

		}

	return err;

	}

CStoreableOverrideSettings* CSelectionRequest::MapPrefsToOverridesL(TCommDbConnPref& aPrefs, const TConnectionSettings& aSettings)

/**

Convert user's connection preferences into an override setting

@param aPrefs a set of connection preferences passed in by the user

@param aSettings the current default connection preference settings

@return override settings matching the supplied connection preferences or NULL if the TCommDbConnPref is empty

@exception leaves if OOM or database access fails

*/

	{

	CCommsDbConnectionPrefTableView::TCommDbIapConnectionPref iapPref;

	// set rank to this connection attempt

	iapPref.iRanking = aSettings.iRank;

	// always use direction given in prefs

	iapPref.iDirection = aSettings.iDirection;

	// if specified, use the settings given in the connection

	// preferences - otherwise read the default values from CommDb

	TBool useOverrides(EFalse);

	if(aPrefs.DialogPreference() != ECommDbDialogPrefUnknown)

		{

		LOG( NetConLog::Printf(_L("\tDialog Preference overriden to %d"), aPrefs.DialogPreference()); )

		iapPref.iDialogPref = aPrefs.DialogPreference();

		useOverrides = ETrue;

		}

	else

		{

		// use current connection preference dialog setting from database

		iapPref.iDialogPref = aSettings.iDialogPref;

		aPrefs.SetDialogPreference(aSettings.iDialogPref);

		}

	if(aPrefs.BearerSet() != KCommDbBearerUnknown)

		{

		LOG( NetConLog::Printf(_L("\tBearer Set overriden to %d"), aPrefs.BearerSet()); )

		iapPref.iBearer.iBearerSet = aPrefs.BearerSet();

		useOverrides = ETrue;

		}

	else

		{

		// use current connection preference BearerSet setting from database

		iapPref.iBearer.iBearerSet = aSettings.iBearerSet;

		aPrefs.SetBearerSet(aSettings.iBearerSet);

		}

	if(aPrefs.IapId() != 0)

		{

		LOG( NetConLog::Printf(_L("\tIAP ID overriden to %d"), aPrefs.IapId()); )

		iapPref.iBearer.iIapId = aPrefs.IapId();

		useOverrides = ETrue;

		}

	else

		{

		// use current connection preference IAP setting from database

		iapPref.iBearer.iIapId = aSettings.iIAPId;

		aPrefs.SetIapId(aSettings.iIAPId);

		}

	CStoreableOverrideSettings* overrides = NULL;

	if (useOverrides)

		{

		overrides = CStoreableOverrideSettings::NewL(CCommDbOverrideSettings::EParamListPartial);

		CleanupStack::PushL(overrides);

		User::LeaveIfError(overrides->SetConnectionPreferenceOverride(iapPref));

		CleanupStack::Pop(); // overrides

		}

	return overrides;

	}

void CSelectionRequest::SetAvailableBearers(TUint32 aBearerSet)

/**

Callback from the Network Controller when the bearer availability check is complete

@param aBearerSet the set of available bearers

*/

	{

	LOG( NetConLog::Printf(_L("\tAvailable Bearer Set = %d"), aBearerSet); )

	// is the selected service available?

	TBool available;

	if( (iSettings.iDialogPref == ECommDbDialogPrefPrompt) || 

	    (iSettings.iDialogPref == ECommDbDialogPrefPromptIfWrongMode))

		{

		/* The ServiceAvailable check is not necessary in prompt mode, since the user hasn't had a chance yet

		   to select the IAP. */

		available = ETrue;

		}

	else

		{

		available = SelectedServiceAvailable(aBearerSet);

		}

	TRAPD(err, SelectIapL(available, aBearerSet));

	if(err!=KErrNone)