/*

* Copyright (c) 2009 Sony Ericsson Mobile Communications AB

* 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:

* Sony Ericsson Mobile Communications AB - initial contribution.

* Nokia Corporation - additional changes.

* 

* Contributors:

* 

* Description:

* Code for CTelephonyFunctions class, used by CTelephony class.

*

*/

/**

 @file

*/

#include "TelephonyFunctions.h"

#include "TelephonyActPhone.h"

#include "TelephonyActSupplServices.h"

#include "TelephonyActLine.h"

#include "TelephonyActCall.h"

#include "TelephonyActNetwork.h"

#include <commsdattypesv1_1.h>

#include <cdblen.h>

#include <commsdat_partner.h>

using namespace CommsDat;

// construct/destruct

CTelephonyFunctions* CTelephonyFunctions::NewLC()

/**

Constructs a CTelephonyFunctions object.

A pointer to this object is left on the CleanupStack.

@leave	Leaves if no memory, or underlying Etel DLL returns error.

@return	Pointer to a newly created CTelephonyFunctions object connected to an RTelServer.

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTelephonyFunctions* CTelephonyFunctions::NewL()

/**

Constructs a CTelephonyFunctions object.

@leave	Leaves if no memory, or underlying Etel DLL returns error.

@return	pointer to a newly created CTelephonyFunctions object connected to an RTelServer.

*/

	{

	CTelephonyFunctions* self=NewLC();

	CleanupStack::Pop();

	return self;

	}

CTelephonyFunctions::~CTelephonyFunctions()

/**

Destructor

*/

	{

	CleanUp();

	if (iTelServerIsOpen)

		{

		iTelServer.Close();

		}

	iReqPendingTable.Close();

	iReqStatusTable.Close();

	iCallPool.Close();

	iCallPoolStatus.Close();

	iPhonePowerProperty.Close();

	}

/**

Cleans up any outstanding "Open" objects.

*/

void CTelephonyFunctions::CleanUp()

	{

	for ( TInt i=0;i<iReqPendingTable.Count(); i++)

		{

		if(iReqPendingTable[i]!=EFalse)

			{

			User::RequestComplete(iReqStatusTable[i], KErrCancel);

			}

		}

	iState = ECleaningUp;

	if(iGetPhoneId!=NULL)

		{

		delete iGetPhoneId;

		iGetPhoneId = NULL;

		}

	if(iGetSubscriberId!=NULL)

		{

		delete iGetSubscriberId;

		iGetSubscriberId = NULL;

		}

	if(iGetIndicator!=NULL)

		{

		delete iGetIndicator;

		iGetIndicator = NULL;

		}

	if(iGetBatteryInfo!=NULL)

		{

		delete iGetBatteryInfo;

		iGetBatteryInfo = NULL;

		}

	if(iGetSignalStrength!=NULL)

		{

		delete iGetSignalStrength;

		iGetSignalStrength = NULL;

		}

	if(iGetIccLockInfo!=NULL)

		{

		delete iGetIccLockInfo;

		iGetIccLockInfo = NULL;

		}

	if(iSendDTMFTones!=NULL)

		{

		delete iSendDTMFTones;

		iSendDTMFTones = NULL;

		}

	if(iDialNewCall!=NULL)

		{

		delete iDialNewCall;

		iDialNewCall = NULL;

		}

	if(iHold!=NULL)

		{

		delete iHold;

		iHold = NULL;

		}

	if(iResume!=NULL)

		{

		delete iResume;

		iResume = NULL;

		}

	if(iSwap!=NULL)

		{

		delete iSwap;

		iSwap = NULL;

		}

	if(iHangup!=NULL)

		{

		delete iHangup;

		iHangup = NULL;

		}

	if(iAnswerIncomingCall!=NULL)

		{

		delete iAnswerIncomingCall;

		iAnswerIncomingCall = NULL;

		}

	if(iGetNetworkRegistrationStatus!=NULL)

		{

		delete iGetNetworkRegistrationStatus;

		iGetNetworkRegistrationStatus = NULL;

		}

	if(iGetCurrentNetworkInfo!=NULL)

		{

		delete iGetCurrentNetworkInfo;

		iGetCurrentNetworkInfo = NULL;

		}

	if(iGetCurrentNetworkName!=NULL)

		{

		delete iGetCurrentNetworkName;

		iGetCurrentNetworkName = NULL;

		}

	if(iGetOperatorName!=NULL)

		{

		delete iGetOperatorName;

		iGetOperatorName = NULL;

		}

	if(iGetCFSupplementaryServiceStatus!=NULL)

		{

		delete iGetCFSupplementaryServiceStatus;

		iGetCFSupplementaryServiceStatus = NULL;

		}

	if(iGetCBSupplementaryServiceStatus!=NULL)

		{

		delete iGetCBSupplementaryServiceStatus;

		iGetCBSupplementaryServiceStatus = NULL;

		}

	if(iGetCWSupplementaryServiceStatus!=NULL)

		{

		delete iGetCWSupplementaryServiceStatus;

		iGetCWSupplementaryServiceStatus = NULL;

		}

	if(iGetIdentityServiceStatus!=NULL)

		{

		delete iGetIdentityServiceStatus;

		iGetIdentityServiceStatus = NULL;

		}

	if(iFlightModeChange!=NULL)

		{

		delete iFlightModeChange;

		iFlightModeChange = NULL;

		}

	if(iNotifyIndicator!=NULL)

		{

		delete iNotifyIndicator;

		iNotifyIndicator = NULL;

		}

	if(iNotifyBatteryInfo!=NULL)

		{

		delete iNotifyBatteryInfo;

		iNotifyBatteryInfo = NULL;

		}

	if(iNotifySignalStrength!=NULL)

		{

		delete iNotifySignalStrength;

		iNotifySignalStrength = NULL;

		}

	if(iNotifyIccLockInfo!=NULL)

		{

		delete iNotifyIccLockInfo;

		iNotifyIccLockInfo = NULL;

		}

	if(iNotifyNetworkRegStatus!=NULL)

		{

		delete iNotifyNetworkRegStatus;

		iNotifyNetworkRegStatus = NULL;

		}

	if(iNotifyCurrentNetworkInfo!=NULL)

		{

		delete iNotifyCurrentNetworkInfo;

		iNotifyCurrentNetworkInfo = NULL;

		}

	if(iNotifyOwnedCall1Status!=NULL)

		{

		delete iNotifyOwnedCall1Status;

		iNotifyOwnedCall1Status = NULL;

		}

	if(iNotifyOwnedCall2Status!=NULL)

		{

		delete iNotifyOwnedCall2Status;

		iNotifyOwnedCall2Status = NULL;

		}

	if(iNotifyOwnedCall1RemoteInfo!=NULL)

		{

		delete iNotifyOwnedCall1RemoteInfo;

		iNotifyOwnedCall1RemoteInfo = NULL;

		}

	if(iNotifyOwnedCall2RemoteInfo!=NULL)

		{

		delete iNotifyOwnedCall2RemoteInfo;

		iNotifyOwnedCall2RemoteInfo = NULL;

		}

	// Delete the internal active objects last

	if(iInternalNotifyVoiceLineStatus!=NULL)

		{

		delete iInternalNotifyVoiceLineStatus;

		iInternalNotifyVoiceLineStatus = NULL;

		}

	if (iInternalNotifyIncomingCall!=NULL)

		{

		delete iInternalNotifyIncomingCall;

		iInternalNotifyIncomingCall = NULL;

		}

	if(iCallIsOpen)

		{

		iCallIsOpen = EFalse;

		iCall.Close();

		}

	for(TInt k = 0; k < iCallPool.Count(); k++)

		{

		iCallPool[k].Close();

		}

	for(TInt k = 0; k < iCallPoolStatus.Count(); k++)

		{

		iCallPoolStatus[k] = EUnset;

		}

	if(iLineIsDataOpen)

		{

		iLineIsDataOpen = EFalse;

		iLineData.Close();

		}

	if(iLineIsVoiceOpen)

		{

		iLineIsVoiceOpen = EFalse;

		iLineVoice.Close();

		}

	if(iLineIsFaxOpen)

		{

		iLineIsFaxOpen = EFalse;

		iLineFax.Close();

		}

	if(iPhoneIsOpen)

		{

		iPhoneIsOpen = EFalse;

		iPhone.Close();

		}

	iState = EIdle;	// all cleaned up.

	}

CTelephonyFunctions::CTelephonyFunctions()

/**

First-phase constructor

private function which cannot Leave().

*/

: iState(EIdle),

  iReqStatusTable(EMaxNumberOperations),

  iReqPendingTable(EMaxNumberOperations),  

  iCallPool(CTelephony::EISVMaxNumOfCalls),

  iCallPoolStatus(CTelephony::EISVMaxNumOfCalls)

	{

	}

void CTelephonyFunctions::ConstructL()

/**

Second-phase constructor

*/

	{

#ifdef __WINS__

	// When bootstrapping C32 we have to avoid the PhBkSyncServer being started, since

  	// it needs a different CommDB

	_LIT(KPhbkSyncCMI, "phbsync.cmi");

	TInt err = StartC32WithCMISuppressions(KPhbkSyncCMI);		// Start Comms server if not already active.

	if( err!=KErrNone && err!=KErrAlreadyExists )

		{

		User::Leave(err);

		}

#endif

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

	iTelServerIsOpen = ETrue;

	User::LeaveIfError(iPhonePowerProperty.Attach(KUidSystemCategory, KUidPhonePwr.iUid));

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

		{

		TRequestStatus dummy(KErrNone);

		}

	for( TInt j=0; j<CTelephony::EISVMaxNumOfCalls; j++)

		{

		RMobileCall aDummyCall;

		}

	__ASSERT_DEBUG(iState==EIdle, User::Invariant());

	InitialisePhoneL();

	}

void CTelephonyFunctions::GetCommDbTSYnameL(TDes& aTsyName)

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	CMDBField<TDesC>* globalSettingField = new(ELeave) CMDBField<TDesC>(KCDTIdBearerAvailabilityCheckTSY);

	CleanupStack::PushL(globalSettingField);

	globalSettingField->SetRecordId(1);

	globalSettingField->SetMaxLengthL(KMaxTextLength);

	globalSettingField->LoadL(*db);

	aTsyName = *globalSettingField;

	CleanupStack::PopAndDestroy(globalSettingField);

	CleanupStack::PopAndDestroy(db);

	}

void CTelephonyFunctions::InitialisePhoneL()

/**

Finds the first data-Line and Open()'s the Phone and Line.

@leave	Leaves if underlying ETEL.DLL returns error,

or if we can't find a suitable Phone/Line or can't open it.

*/

	{

	TBuf<KCommsDbSvrMaxFieldLength> tsyName;

	GetCommDbTSYnameL(tsyName);

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

	TInt numPhones;

	User::LeaveIfError(iTelServer.EnumeratePhones(numPhones));

	TInt phoneIndx;

	TInt ret = KErrHardwareNotAvailable;

	RPhone::TLineInfo lineInfo;

	for(phoneIndx=0; phoneIndx<numPhones; phoneIndx++)

		{

		RTelServer::TPhoneInfo tInfo;

		ret = iTelServer.GetPhoneInfo(phoneIndx, tInfo);

		if(ret != KErrNone)

			{

			continue;

			}

		ret = iPhone.Open(iTelServer, tInfo.iName);	

		if(ret != KErrNone)

			{

			continue;

			}

		iPhoneIsOpen = ETrue;

		RPhone::TStatus status;

		User::LeaveIfError(iPhone.GetStatus(status));

		if(status.iModemDetected!=RPhone::EDetectedPresent)

			{

			ret = iPhone.Initialise();

			if(ret != KErrNone)

				{

				iPhone.Close();

				iPhoneIsOpen = EFalse;

				continue;

				}

			}

		TInt lines;

		ret = iPhone.EnumerateLines(lines);

		if(ret != KErrNone)

			{

			iPhone.Close();

			iPhoneIsOpen = EFalse;

			continue;

			}

		if(lines<1)

			{

			ret = KErrEtelWrongModemType;

			iPhone.Close();

			iPhoneIsOpen = EFalse;

			continue;

			}

		TInt lineIndx;

		TBool lineVoiceFound=EFalse, lineFaxFound=EFalse, lineDataFound=EFalse;

		for(lineIndx=0; lineIndx<lines; lineIndx++)

			{

			if(iPhone.GetLineInfo(lineIndx, lineInfo) != KErrNone)

				{

				continue;

				}

			if((lineInfo.iLineCapsFlags & RLine::KCapsVoice)&&(!lineVoiceFound))

				{

				User::LeaveIfError(iLineVoice.Open(iPhone, lineInfo.iName));

				iLineIsVoiceOpen = ETrue;

				lineVoiceFound = ETrue;

				iLineVoiceName.Copy(lineInfo.iName);

				continue;

				}

			else if((lineInfo.iLineCapsFlags & RLine::KCapsData)&&(!lineDataFound))

				{

				User::LeaveIfError(iLineData.Open(iPhone, lineInfo.iName));

				iLineIsDataOpen = ETrue;

				lineDataFound = ETrue;

				continue;

				}

			else if((lineInfo.iLineCapsFlags & RLine::KCapsFax)&&(!lineFaxFound))

				{

				User::LeaveIfError(iLineFax.Open(iPhone, lineInfo.iName));

				iLineIsFaxOpen = ETrue;

				lineFaxFound = ETrue;

				continue;

				}

			}

		if(!iLineIsVoiceOpen)

			{

			ret = KErrEtelWrongModemType;

			iPhone.Close();

			iPhoneIsOpen = EFalse;

			continue;

			}

		//get TSY version

		TBool result;

		iTsyVersion = KETelExtMultimodeV3;

		User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));

		if(!result)

			{

			iTsyVersion = KETelExtMultimodeV2;

			User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));

			if(!result)

				{

				iTsyVersion = KETelExtMultimodeV1;

				User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));

				if(!result)

					{

					iTsyVersion = KNoMultimodeTsy;

					}

				}

			}

		//

		// A CTelephonyFunctions object is always listening for a change

		// in the line status and for an incoming call.

		// The iInternalNotifyVoiceLineStatus and iInternalNotifyIncoming

		// call objects persist throughout this object's lifetime.

		// Create the internal active objects and post the first request.

		//