// Copyright (c) 1997-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 "PHONE.H"

#include "LINE.H"

#include "CALL.H"

#include "mSLOGGER.H"

#include "mnetwork.h"

#include "GprsNotify.h"

//

//	CNotifications - handles array of notifications placed on TSY

//

CNotifications* CNotifications::NewL()

	{

	CNotifications* notifications=new(ELeave) CNotifications();

	CleanupStack::PushL(notifications);

	notifications->ConstructL();

	CleanupStack::Pop();

	return notifications;

	}

CNotifications::CNotifications()

	{}

void CNotifications::ConstructL()

	{

	iNotifications = new (ELeave) CArrayPtrFlat<CNotifyBase>(4);

	iLastEvents = new (ELeave) CArrayFixFlat<TLastEvent>(4);

	}

CNotifications::~CNotifications()

//

//	Notifications are removed by server prior to this

//

	{

	if(iNotifications)

		{

		__ASSERT_ALWAYS(iNotifications->Count()==0,Panic(ENotifications_Remaining));

		delete iNotifications;

		}

	if(iLastEvents)

		{

		__ASSERT_ALWAYS(iLastEvents->Count()==0,Panic(ELastEvents_Remaining));

		delete iLastEvents;

		}

	}

//

//	Last Events

//

//	The most recent event to occur must be stored in the notification handler to be compared

//  with the event passed with CheckNotification(), so that they can be compared (if they are 

//  equal, the notification should not be completed).

//	Each TelObject to use this Notification handler has a last event associated with it.

//	The first time a TelObject calls RegisterNotification() to add a notification to the array, 

//	an entry is made in the iLastEvents array connecting this TelObject with an event (to start

//  with this is ENoEvent).

//	When the notification completes, the LastEvent entry remains, as even if a TelObject has no

//	notifications outstanding there must still be a record of its last event. This LastEvent

//	entry must only be removed when the TelObject is destroyed, hence in the destructor of 

//	each of CPhoneHayes, CLineHayes, CCallHayes and CFaxHayes RemoveClientFromLastEvents() is

//  called.

//

TInt CNotifications::FindLastEvent(CTelObject* aTelObject)

//

// Finds the last event to occur to this TelObject

// Returns the position in the array

//

	{

	for (TInt i=0;i<iLastEvents->Count();i++)

		{

		if (iLastEvents->At(i).iTelObject==aTelObject)

			return i;

		}

	return KErrNotFound;

	}

TInt CNotifications::GetLastEvent(CTelObject* aTelObject, TLastEvent& aLastEvent)

//

//	Searches for the relevant Last Event entry by TelObject, returns the reference to entry

//  and its position

//

	{

	TInt pos = FindLastEvent(aTelObject);

	if (pos!=KErrNotFound)

		{

		aLastEvent = iLastEvents->At(pos);

		}

	return pos;

	}

TInt CNotifications::AddLastEvent(CTelObject* aTelObject,TEvent aLastEvent)

//

//	Searches for relevant entry. If exists, updates it with new event. If not, appends a new

//	entry to the array.

//

	{

	TLastEvent lastEvent;

	lastEvent.iLastEvent=aLastEvent;

	TInt pos = FindLastEvent(aTelObject);

	if (pos!=KErrNotFound)

		{

		iLastEvents->At(pos).iLastEvent=lastEvent.iLastEvent; // Update array element's iLastEvent.

		}

	else

		{	

		lastEvent.iTelObject=aTelObject;

		TRAPD(ret, iLastEvents->AppendL(lastEvent,1) );

		if (ret!=KErrNone)

			{

			LOGTEXT2(_L8("CNotifications::AddLastEvent Append failed with error %d"), ret);

			return ret; 

			}

		}

	return pos;

	}

//

//	public functions

//

void CNotifications::RemoveClientFromLastEvents(CTelObject* aTelObject)

//

//	The notification store needs to know when a TelObject is closed so it can remove its

//  entry in the Last Events list.

	{

	for (TInt i=0;i<iLastEvents->Count();i++)

		{

		if (iLastEvents->At(i).iTelObject==aTelObject)

			{

			iLastEvents->Delete(i);

			return;

			}

		}

	}

void CNotifications::RemoveEventFromLastEvents(TEvent aEvent)

//

// The removes all events of a particular type from the event list.  It is used when a line stops

// ringing to remove all ringing references.

//

	{

	for (TInt i=0;i<iLastEvents->Count();i++)

		{

		if (iLastEvents->At(i).iLastEvent==aEvent)

			{

			iLastEvents->Delete(i);

			return;

			}

		}

	}

void CNotifications::RegisterNotification(TNotifications aWhichNotification,TTsyReqHandle aTsyReqHandle,CTelObject* aTelObject,TAny* aParams)

	{

	CNotifyBase* newNotify = NULL;

	TInt ret=KErrNone;

	switch (aWhichNotification)

		{

	case EModemDetection:

		TRAP(ret,newNotify = CNotifyModemDetected::NewL((RPhone::TModemDetection*)aParams,aTsyReqHandle,aTelObject));

		break;

	case EIncomingCall:

		TRAP(ret,newNotify = CNotifyIncomingCall::NewL((TDes*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ELineHookChange:

		TRAP(ret,newNotify = CNotifyLineHookChange::NewL((RCall::THookStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ECallHookChange:

		TRAP(ret,newNotify = CNotifyCallHookChange::NewL((RCall::THookStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ELineStatusChange:

		TRAP(ret,newNotify = CNotifyLineStatusChange::NewL((RCall::TStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case EMobileLineStatusChange:

		TRAP(ret,newNotify = CNotifyMobileLineStatusChange::NewL((RMobileCall::TMobileCallStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ECallDurationChange:

		TRAP(ret,newNotify = CNotifyCallDurationChange::NewL((TTimeIntervalSeconds*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ENewCallAdded:

		TRAP(ret,newNotify = CNotifyLineNewCallAdded::NewL((TDes*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ECallStatusChange:

		TRAP(ret,newNotify = CNotifyCallStatusChange::NewL((RCall::TStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case EMobileCallStatusChange:

		TRAP(ret,newNotify = CNotifyMobileCallStatusChange::NewL((RMobileCall::TMobileCallStatus*)aParams,aTsyReqHandle,aTelObject));

		break;

	case EReadOrWriteFax:

		TRAP(ret,newNotify = CNotifyFaxReadOrWrite::NewL(aTsyReqHandle,aTelObject));

		break;

	case EEndOfFaxPage:

		TRAP(ret,newNotify = CNotifyFaxEndOfPage::NewL(aTsyReqHandle,aTelObject));

		break;

	case ECallCaps:

		TRAP(ret,newNotify = CNotifyCallCaps::NewL((RCall::TCaps*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ECallMobileCaps:

		TRAP(ret,newNotify = CNotifyMobileCallCaps::NewL((TDes8*)aParams,aTsyReqHandle,aTelObject));

		break;

	case ERegistrationStatus:

		TRAP(ret,newNotify = CNotifyNetworkRegistrationStatusChange::NewL(aTsyReqHandle,aTelObject,(RMobilePhone::TMobilePhoneRegistrationStatus*)aParams));

		break;

	case ECurrentNetwork:

		TRAP(ret,newNotify = CNotifyCurrentNetworkChange::NewL(aTsyReqHandle,aTelObject,(TInt*)aParams)); 

		break;

	// GPRS

	case EPacketContextAdded:

		TRAP(ret,newNotify = CGprsContextAddedNotify::NewL(aTsyReqHandle,aTelObject,(TDes*)aParams));

		break; 

	case EPacketStatusChange:

		TRAP(ret,newNotify = CGprsStatusNotify::NewL(aTsyReqHandle,aTelObject,(RPacketService::TStatus*)aParams));

		break;

	case EPacketNtwkRegStatusChange:

		TRAP(ret,newNotify = CGprsNtwkRegStatusChangeNotify::NewL(aTsyReqHandle,aTelObject,(RPacketService::TRegistrationStatus*)aParams));

		break;

	// GPRS context

	case EPacketContextConfigChange:

		TRAP(ret,newNotify = CGprsContextConfigNotify::NewL(aTsyReqHandle,aTelObject,(TDes8*)aParams));

		break;

	case EPacketContextStatusChange:

		TRAP(ret,newNotify = CGprsContextStatusNotify::NewL(aTsyReqHandle,aTelObject,(RPacketContext::TContextStatus*)aParams));

		break;

	// GPRS QoS

	case EPacketQoSProfileChange:

		TRAP(ret,newNotify = CGprsQoSProfileNotify::NewL(aTsyReqHandle, aTelObject, (TDes8*)aParams));

		break;

	default:

		Panic(EIllegalEvent);

		break;

		}

	if (ret!=KErrNone)

		{

		aTelObject->ReqCompleted(aTsyReqHandle,ret);

		delete newNotify;

		}

	else

		{

		TRAP(ret,RegisterNotificationL(newNotify));

		if (ret!=KErrNone)

			aTelObject->ReqCompleted(aTsyReqHandle,ret);

		}

	}

void CNotifications::RegisterNotificationL(CNotifyBase* aNotify)

	{

	iNotifications->AppendL(aNotify);

	TInt pos = FindLastEvent(aNotify->TelObject());

	if (pos==KErrNotFound)

		{

		TLastEvent lastEvent;

		lastEvent.iTelObject=aNotify->TelObject();

		lastEvent.iLastEvent=ENoEvent;

		iLastEvents->AppendL(lastEvent,1);

		}

	}

void CNotifications::CheckNotification(CTelObject* aTelObject,TEvent aEvent)

//

//	Due to the possibility of immediate re-posting of notification from server which may

//	initiate another CheckNotification synchronously causing the problem that the last event

//  has not yet been set to current event - an infinite loop occurs. Fixed here by setting

//  a boolean on entry and resetting on exit

//

	{

	if (iAlreadyChecking)

		return;

	iAlreadyChecking = ETrue;

	TLastEvent lastEvent;

	TInt ret = GetLastEvent(aTelObject,lastEvent);

	if (ret==KErrNotFound)

		lastEvent.iLastEvent=ENoEvent;	// to be passed to each notify object

	TBool flag=EFalse;

	for (TInt i=iNotifications->Count(); i>0; i--)

		{

		CNotifyBase* notify = iNotifications->At(i-1);

		if(notify->CheckAndCompleteNotification(aTelObject,aEvent,lastEvent.iLastEvent))

			{

			iNotifications->Delete(i-1);

			delete notify;

			flag=ETrue;

			}

		}

	if (flag)

		iNotifications->Compress();

	ret = AddLastEvent(aTelObject,aEvent);

	__ASSERT_ALWAYS( ret == KErrNotFound  || ret >= 0,Panic(EGeneral));

	iAlreadyChecking = EFalse;

	}

void CNotifications::CheckNotification(CCallBase* aCallObject,TEvent aEvent)

	{

	if (iAlreadyChecking)

		return;

	iAlreadyChecking = ETrue;

	TLastEvent lastEvent;

	TInt ret = GetLastEvent(aCallObject,lastEvent);

	if (ret==KErrNotFound)

		lastEvent.iLastEvent=ENoEvent;

	TBool flag=EFalse;

	for (TInt i=iNotifications->Count(); i>0; i--)

		{

		CNotifyBase* notify = iNotifications->At(i-1);

		if (notify->CheckAndCompleteNotification(aCallObject,aEvent,lastEvent.iLastEvent))

			{

			iNotifications->Delete(i-1);

			delete notify;

			flag=ETrue;

			}

		}

	if (flag)

		iNotifications->Compress();

	ret = AddLastEvent(aCallObject,aEvent);

	__ASSERT_ALWAYS( ret == KErrNotFound  || ret >= 0,Panic(EGeneral));

	iAlreadyChecking = EFalse;

	}

void CNotifications::CheckNotification(CFaxSession* aETelFaxObject,TEvent aEvent,TInt aError,TAny* aParams)

	{

	iAlreadyChecking = ETrue;

	TBool flag=EFalse;

	for (TInt i=iNotifications->Count(); i>0; i--)

		{

		CNotifyBase* notify = iNotifications->At(i-1);

		if (notify->CheckAndCompleteNotification(aETelFaxObject,aEvent,aError,aParams))

			{

			iNotifications->Delete(i-1);

			delete notify;

			flag=ETrue;

			}

		}

	if (flag)

		iNotifications->Compress();

	iAlreadyChecking = EFalse;

	}

//

//

// This function is added to deal specifically with notifications only (ie: no events)

// An incoming SMS message notification for example!

//

//

void CNotifications::CheckNotification(CTelObject* aTelObject, TNotifications aNotification)

	{

	if (iAlreadyChecking)

		return;

	iAlreadyChecking = ETrue;

	TBool flag = EFalse;

	for (TInt i = 0; i<iNotifications->Count(); i++)

		{

		CNotifyBase* notify = iNotifications->At(i);

		if (notify->CheckAndCompleteNotification(aTelObject, aNotification))

			{

			iNotifications->Delete(i);

			delete notify;

			flag = ETrue;

			} 

		} 

	if (flag)

		iNotifications->Compress();

	iAlreadyChecking = EFalse;

}

void CNotifications::RemoveNotification(TTsyReqHandle aTsyReqHandle)

//

//	Cancel a notification by its TsyReqHandle (unique to that notification)

//

	{

	for (TInt i=0;i<iNotifications->Count();i++)

		{

		CNotifyBase* notify = iNotifications->At(i);

		if (notify->TsyReqHandle() == aTsyReqHandle)

			{

			notify->TelObject()->ReqCompleted(notify->TsyReqHandle(),KErrCancel);

			iNotifications->Delete(i);

			delete notify;

			break;

			}

		}

	}

void CNotifications::CompleteNotificationsWithError(TInt aError)

	{

	for (TInt i=0;i<iNotifications->Count();i++)

		{

		CNotifyBase* notify = iNotifications->At(0);

		notify->TelObject()->ReqCompleted(notify->TsyReqHandle(),aError);

		iNotifications->Delete(0);

		delete notify;

		}

	}

//

//	CNotifyBase class - base class for all notifications

//

CNotifyBase::CNotifyBase(TTsyReqHandle aReqHandle,CTelObject* aTelObject)

	: iReqHandle(aReqHandle),iTelObject(aTelObject)

	{}

CNotifyBase::~CNotifyBase()

	{}

TTsyReqHandle CNotifyBase::TsyReqHandle()

	{

	return iReqHandle;

	}

CTelObject* CNotifyBase::TelObject()

	{

	return iTelObject;

	}

TBool CNotifyBase::CheckAndCompleteNotification(CTelObject* /*aTelObject*/,TEvent /*aEvent*/,TEvent /*aLastEvent*/)

	{

	return EFalse;

	}

TBool CNotifyBase::CheckAndCompleteNotification(CCallBase* /*aCallObject*/,TEvent /*aEvent*/,TEvent /*aLastEvent*/)

	{

	return EFalse;

	}

TBool CNotifyBase::CheckAndCompleteNotification(CFaxSession* /*aETelFaxObject*/,TEvent /*aEvent*/,TInt /*aError*/,TAny* /*aParams*/)

	{

	return EFalse;

	}

TBool CNotifyBase::CheckAndCompleteNotification(CTelObject* /*aTelObject*/, TNotifications /*aNotification*/)

	{

	return EFalse;

	}

//

// CNotifyPhoneDetection

//

CNotifyModemDetected* CNotifyModemDetected::NewL(RPhone::TModemDetection* aDetection,TTsyReqHandle aReqHandle,CTelObject* aTelObject)

	{

	return new(ELeave) CNotifyModemDetected(aDetection,aReqHandle,aTelObject);

	}

CNotifyModemDetected::CNotifyModemDetected(RPhone::TModemDetection* aDetection,TTsyReqHandle aReqHandle,CTelObject* aTelObject)

	 : CNotifyBase(aReqHandle,aTelObject),iDetection(aDetection)

	{}

CNotifyModemDetected::~CNotifyModemDetected()

	{}

TBool CNotifyModemDetected::CheckAndCompleteNotification(CTelObject* /*aTelObject*/,TEvent aEvent,TEvent aLastEvent)

//

//	After phone has been in the "Not detected" state, the next state should be "Detected"

//  or a "Ring Occurred"

//  

	{

	if ((aEvent==ERingOccurred || aEvent==EPhoneDetected)

		&&(aLastEvent==EPhoneNotDetected || aLastEvent==ENoEvent))

		{

		*iDetection=RPhone::EDetectedPresent;

		}

	else if (aEvent==EPhoneNotDetected && aLastEvent!=EPhoneNotDetected)

		{

		*iDetection=RPhone::EDetectedNotPresent;

		}

	else return EFalse;

	LOGTEXT2(_L8("Event %d:\tModem Detection Change Notification completed"),aEvent);

	iTelObject->ReqCompleted(iReqHandle,KErrNone);

	return ETrue;

	}

TBool CNotifyModemDetected::CheckAndCompleteNotification(CCallBase* aCallObject,TEvent aEvent,TEvent aLastEvent)

	{

	return CheckAndCompleteNotification(STATIC_CAST(CTelObject*,aCallObject),aEvent,aLastEvent);

	}

//

// CNotifyIncomingCall

//

CNotifyIncomingCall* CNotifyIncomingCall::NewL(TDes* aName,TTsyReqHandle aReqHandle,CTelObject* aTelObject)

	{

	return new(ELeave) CNotifyIncomingCall(aName,aReqHandle,aTelObject);

	}

CNotifyIncomingCall::CNotifyIncomingCall(TDes* aName,TTsyReqHandle aReqHandle,CTelObject* aTelObject)

	 : CNotifyBase(aReqHandle,aTelObject),iName(aName)

	{}

CNotifyIncomingCall::~CNotifyIncomingCall()

	{}

TBool CNotifyIncomingCall::CheckAndCompleteNotification(CTelObject* aTelObject,TEvent aEvent,TEvent aLastEvent)

//

//	Checks that the last event to happen was not an incoming call. 

//  Adv: If the first Notification for an incoming call is placed after the line started ringing,

//		 it can check the line status and complete immediately.

	{

	if (aEvent==ERingOccurred && aLastEvent!=ERingOccurred

		&& aTelObject==iTelObject)

		{

		CLineHayes* line = STATIC_CAST(CLineHayes*,iTelObject);

		line->GetNameOfCallForAnswering(*iName);

		line->ResetNotifyIncomingCall();	

		LOGTEXT2(_L8("Event %d:\tIncoming Call Notification completed"),aEvent);

		iTelObject->ReqCompleted(iReqHandle,KErrNone);

		return ETrue;

		}

	return EFalse;

	}