// 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 CTelBearer.cpp

*/

#include "CTelBearer.h"

#include "NetConLog.h"

#include "NetConError.h"

#include "NetConPanic.h"

#include <comms-infras/dbaccess.h>

#include <agentdialog.h>  // for TConnectionPrefs

#include "CNetworkController.h"

CTelBearer::~CTelBearer()

/**

Destructor

*/

	{

	CloseTelephony();

	if(iStartCheckingCb)

		{

		iStartCheckingCb->Cancel();

		}

	// Note:  iBearerCompleteCb is declared in the base class CBearerBase.

	if(iBearerCompleteCb)

		{

		iBearerCompleteCb->Cancel();

		}

	delete iStartCheckingCb;

	iStartCheckingCb = NULL;

	delete iBearerCompleteCb;

	iBearerCompleteCb = NULL;

	delete iTsyName;

	iTsyName = NULL;

	}

CTelBearer* CTelBearer::NewLC(MBearerObserver* aObserver)

/**

Factory function - creates a new CTelBearer

On return the new object is left on the cleanup stack

@param aObserver, checks for bearer availability 

@param aDatabase,allow the requests and bearers access to the database..

@return the new CTelBearer object

@exception leaves if construction fails

*/

	{

	CTelBearer* self = new(ELeave) CTelBearer(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTelBearer* CTelBearer::NewL(MBearerObserver* aObserver)

/**

Factory function - creates a new CTelBearer

@param aObserver, checks for bearer availability 

@param aDatabase,allow the requests and bearers access to the database..

@return the new CTelBearer object

@exception leaves if construction fails

*/

	{

	CTelBearer* self = CTelBearer::NewLC(aObserver);

	CleanupStack::Pop(); // self

	return self;

	}

CTelBearer::CTelBearer(MBearerObserver* aObserver)

: CBearerBase(aObserver)

/**

Constructor

*/

	{ }

void CTelBearer::ConstructL()

/**

2nd phase of construction

@exception leaves if 2nd phase construction fails 

*/

	{

	// call base class ConstructL()

	CBearerBase::ConstructL();

	// Set up start checking callback

	TCallBack callback(StartCheckingCb, this);

	iStartCheckingCb = new (ELeave) CAsyncCallBack(callback, CActive::EPriorityStandard);

	}

void CTelBearer::AssignSupportedBearerSet()

/**

Assign the supported telephony bearer set.

*/

	{

	// identify bearer type of this object

	iSupportedBearerSet = (KCommDbBearerCSD | KCommDbBearerPSD);

	}

void CTelBearer::Disconnect()

/**

Trigger all agents on this bearer to disconnect

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tDisconnect()")); )

	}

TBool CTelBearer::StartChecking()

/**

Start checking for availability

@return ETrue if available else EFalse

*/

	{

	return StartChecking(EFalse);

	}

TBool CTelBearer::StartChecking(TBool aIsReconnect)

/**

Start checking for availability

@param aIsReconnect, if this is a reconnection then any asynchronous requests are skipped in order to speed things up.

@return ETrue if available else EFalse

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tStartChecking()")); )

	if (iChecking)

		return EFalse;

	iChecking = ETrue;

	iIsReconnect = aIsReconnect;

	iStartCheckingCb->CallBack();

	return ETrue;

	}

TInt CTelBearer::StartCheckingCb(TAny* aThisPtr)

/**

Callback initiated from StartChecking()

@param aThisPtr a pointer to the instance of this class that initiated the callback

@return KErrNone always

*/

	{

	CTelBearer* self = (CTelBearer*) aThisPtr;

	self->CheckBearerSupport();

	return KErrNone;

	}

TBool CTelBearer::StopChecking()

/**

Stop checking for availability

@return ETrue if stopped else EFalse

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tStopChecking()")); )

	if (!iChecking)

		return EFalse;

	iStartCheckingCb->Cancel();

	// Note:  iBearerCompleteCb is declared in the base class CBearerBase.

	iBearerCompleteCb->Cancel();

	iChecking = EFalse;

	// free telephony resources

	CloseTelephony();

	return ETrue;

	}

void CTelBearer::CheckBearerSupport()

/**

Find out which bearers are available

*/

	{

	LOG( NetConLog::Printf(_L("TelBearer:\tStarting to check for bearer availability")); )

	TRAPD(err, GetBearerSupportL());

	if(err!=KErrNone)

		{

		LOG( NetConLog::Printf(_L("TelBearer:\tError %d during bearer availability check"), err); )

		// something has gone wrong when trying to check availability

		// so stop checking availability and tell the observer that

		// no bearers are available

		StopChecking();

		iAvailableBearerSet = KCommDbBearerUnknown;

		UpdateObserver();

		}

	}

void CTelBearer::GetBearerSupportL()

/**

Retrieve required telephony information and work out which bearers are available

@exception leaves with one of the system-wide error codes

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tGetBearerSupportL()")); )

	OpenTelephonyL();

	RetrievePhoneCapsL();

	RetrieveNetworkModeL();

	RetrievePacketSupportL();

	}

void CTelBearer::OpenTelephonyL()

/**

Initialise telephony resources

@exception leaves with one of the system-wide error codes

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tOpenTelephonyL()")); )

	__ASSERT_DEBUG(iTelServerState == ENotConnected, NetConPanic(NetworkController::ETelBearerBadState));

	// Request pointer to CommDB's access class

	CCommsDbAccess* dbAccess = iObserver->DbAccess();

	// retrieve the TSY name from the database

	// and remove the .tsy extension if necessary

	TFileName tsyName;

	dbAccess->GetBearerAvailabilityTsyNameL(tsyName);

	if (tsyName.Right(4).CompareF(KTsyNameExtension())==0)

		{

		tsyName = tsyName.Left(tsyName.Length() - 4);

		}

	// Remember the tsy name so it can be unloaded

	if(iTsyName)

		{

		delete iTsyName;

		iTsyName = NULL;

		}

	iTsyName = tsyName.AllocL();

	// connect to ETEL

	User::LeaveIfError(iTelServer.Connect());

	iTelServerState = EServerConnected;

	// load the TSY

	User::LeaveIfError(iTelServer.LoadPhoneModule(tsyName));

	iTelServerState = EPhoneModuleLoaded;

	// open the phone module

	OpenPhoneL(iTelServer, tsyName, iMmPhone);

	iTelServerState = EPhoneOpen;

	// start watching signal strength

	iSigStrengthWatcher = CAgentSignalStrengthWatcher::NewL(iMmPhone);

	}

void CTelBearer::CloseTelephony()

/**

Free any telephony resources used

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tCloseTelephony()")); )

	if(iETelServerRequestsWrapper)

		{

		delete iETelServerRequestsWrapper;

		iETelServerRequestsWrapper = NULL;

		}

	if(iSigStrengthWatcher)

		{

		delete iSigStrengthWatcher;

		iSigStrengthWatcher = NULL;

		}

	switch(iTelServerState)

		{

		case EPacketOpen:

			iPacket.Close();

			// ... fall through ...

		case EPhoneOpen:

			iMmPhone.Close();

			// ... fall through ...

		case EPhoneModuleLoaded:

			__ASSERT_ALWAYS(iTsyName, NetConPanic(NetworkController::ETelBearerTsyNameMissing));

			// can't do anything if UnloadPhoneModule fails so ignore return value

			(void)iTelServer.UnloadPhoneModule(*iTsyName);

			// ... fall through ...

		case EServerConnected:

			iTelServer.Close();

			iTelServerState = ENotConnected;

			break;

		case ENotConnected:

			if (iTsyName)

				{

				delete iTsyName;

				iTsyName = NULL;

				}

			break;

		default:

			break;

		}

	}

void CTelBearer::OpenPhoneL(RTelServer& aTelServer, const TDesC& aTsyName, RMobilePhone& aMmPhone)

/**

Open the phone module (ie the TSY)

@param aTelServer the telephony server session

@param aTsyName the name of the phone module to load

@param aMmPhone the phone session in which to load the TSY

@exception leaves with one of the system-wide error codes

*/

	{

	__ASSERT_DEBUG(iTelServerState == EPhoneModuleLoaded, NetConPanic(NetworkController::ETelBearerBadState));

	// find out how many phones are supported (i.e. how many TSYs)

	TInt count = 0;

	User::LeaveIfError(aTelServer.EnumeratePhones(count));

	if (count <= 0)

		User::Leave(KErrNotFound);

	RTelServer::TPhoneInfo info;

	TBool found(EFalse);

	// loop through all the phones and find correct TSY

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

		{

		TBuf<KCommsDbSvrMaxFieldLength> currentTsyName;

		User::LeaveIfError(aTelServer.GetTsyName(i, currentTsyName));

		// remove .TSY extension if necessary

		if (currentTsyName.Right(4).CompareF(KTsyNameExtension())==0)

			{

			currentTsyName = currentTsyName.Left(currentTsyName.Length() - 4);

			}

		// compare current TSY name with the one we're looking for

		if (currentTsyName.CompareF(aTsyName)==0)

			{

			// get phone info from the TSY

			User::LeaveIfError(aTelServer.GetPhoneInfo(i, info));

			found = ETrue;

			break;

			}	

		}

	if (!found)

		User::Leave(KErrNotFound);

	// open multimode phone object

	User::LeaveIfError(aMmPhone.Open(aTelServer, info.iName));

	}

void CTelBearer::RetrievePhoneCapsL()

/**

Query the phone for basic and multimode capabilities

@exception leaves with one of the system-wide error codes

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tRetrievePhoneCapsL()")); )

	__ASSERT_DEBUG(iTelServerState == EPhoneOpen, NetConPanic(NetworkController::ETelBearerBadState));

	// retrieve the basic phone capabilities

	// (ie. whether it supports data calls)

	iPhoneCaps.iFlags = RPhone::KCapsUnknown;

	User::LeaveIfError(iMmPhone.GetCaps(iPhoneCaps));

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiPhoneCaps.iFlags = %d"), iPhoneCaps.iFlags); )

	// retrieve multimode phone capabilities

	User::LeaveIfError(iMmPhone.GetMultimodeCaps(iPhoneMultimodeCaps));

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiPhoneMultimodeCaps = %d"), iPhoneMultimodeCaps); )

	}

void CTelBearer::RetrieveNetworkModeL()

/**

Query the phone for the network mode (e.g. GSM, WCDMA, cdma95 or cdma2000)

Stores the network mode in the database (since it is needed for Mobile IP)

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tRetrieveNetworkModeL()")); )

	__ASSERT_DEBUG(iTelServerState == EPhoneOpen, NetConPanic(NetworkController::ETelBearerBadState));

	// retrieve the current network mode

	// ignore error because the phone might not be able

	// to report this information (eg. a normal modem)

	iNetworkMode = RMobilePhone::ENetworkModeUnknown;

	(void)iMmPhone.GetCurrentMode(iNetworkMode);

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiNetworkMode = %d"), iNetworkMode); )

	// Request pointer to CommDB's access class

	CCommsDbAccess* dbAccess = iObserver->DbAccess();

	// set the network mode in the database

	// this is required for Mobile IP

	dbAccess->SetNetworkMode(iNetworkMode);

	}

void CTelBearer::RetrievePacketSupportL()

/**

Find out if packet switched data is available

@exception leaves with one of the system-wide error codes

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tRetrievePacketSupportL()")); )

	__ASSERT_DEBUG(iTelServerState == EPhoneOpen, NetConPanic(NetworkController::ETelBearerBadState));

	if(iPhoneMultimodeCaps & (RMobilePhone::KCapsGprsSupported))

		{

		// the phone supports packet data 

		// so try and open the packet service

		User::LeaveIfError(iPacket.Open(iMmPhone));

		iTelServerState = EPacketOpen;

		// query the TSY for the attach mode

		iPacketAttachMode = RPacketService::EAttachWhenNeeded;

		TInt err = iPacket.GetAttachMode(iPacketAttachMode);

		// query packet network status (but only if the TSY is set to attach when possible)

		iPacketDataNetworkStatus = RPacketService::EStatusUnattached;

		if(err==KErrNone && iPacketAttachMode == RPacketService::EAttachWhenPossible)

			{

			User::LeaveIfError(iPacket.GetStatus(iPacketDataNetworkStatus));

			}

		LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiPacketDataNetworkStatus = %d"), iPacketDataNetworkStatus); )

		// close packet service as it is no-longer needed

		iPacket.Close();

		iTelServerState = EPhoneOpen;

		if(!iIsReconnect)

			{

			// start asynchronous ETEL requests to retrieve

			// the MS class and the network registration status

			iMsClass = RPacketService::EMSClassUnknown;

			iETelServerRequestsWrapper = CASyncEtelRequestWrapper::NewL(this);

			iETelServerRequestsWrapper->StartAsyncRequests(iTelServer, iMmPhone);

			return;

			}

		}

		LOG_DETAILED( else NetConLog::Printf(_L("TelBearer:\tPacket data is not supported")); )

	CalculateAvailableBearerSet();

	}

void CTelBearer::ETelAsyncRequestsComplete(TETelAsyncRequestData aRequestData)

/**

The MS Class and Network Registration status have been retrieved

Store these values and work out which bearers are available

@param aRequestData contains the information returned from ETEL

*/

	{

	LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tETelAsyncRequestsComplete()")); )

	__ASSERT_DEBUG(iTelServerState == EPhoneOpen, NetConPanic(NetworkController::ETelBearerBadState));

	if (aRequestData.iETelAsynError.iError==KErrNone)

		{

		LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiNetworkRegStatus = %d"), iNetworkRegStatus); )

		LOG_DETAILED( NetConLog::Printf(_L("TelBearer:\tiMsClass = %d"), iMsClass); )

		// data was retrieved sucessfully

		iNetworkRegStatus = aRequestData.iRegistrationStatus;

		iMsClass = aRequestData.iMSClass;

		}

	else

		{

		LOG( NetConLog::Printf(_L("TelBearer:\tAsync ETEL requests completed with error %d)"), aRequestData.iETelAsynError.iError); )

		iNetworkRegStatus = RPacketService::ENotRegisteredNotSearching;

		iMsClass = RPacketService::EMSClassUnknown;

		}

	// we now have all the information we need

	// so work out which bearers are available

	CalculateAvailableBearerSet();

	}

void CTelBearer::CalculateAvailableBearerSet()

/**

Adds each available bearer to the currently available bearer set

and updates the status of this bearer with the bearer manager

*/

	{

	iAvailableBearerSet = KCommDbBearerUnknown;

	if(CsdAvailable())

		iAvailableBearerSet |= KCommDbBearerCSD;

	LOG( NetConLog::Printf(_L("TelBearer:\tFinished availability check - available bearer set is %d"), iAvailableBearerSet); )

	// update the observer with the available bearers