// 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 "dstdiden.h"

#include "DDEF.H"

#include "didendef.h"

//

// CCallDstdIden

//

CCallDstdIden* CCallDstdIden::NewL(CPhoneFactoryDummyBase* aFac)

//

// Create new instance of CCallDstdIden

//

	{

	CCallDstdIden* call=new(ELeave)CCallDstdIden(aFac);

	CleanupStack::PushL(call);

	call->ConstructL();

	CleanupStack::Pop();

	return call;

	}

CCallDstdIden::CCallDstdIden(CPhoneFactoryDummyBase* aFac)

	:CCallDummyBase(aFac)

	{}

CCallDstdIden::~CCallDstdIden()

	{}

TInt CCallDstdIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CCallDstdIden::OpenNewObjectByNameL(const TDesC& /*aName*/)

	{

	return REINTERPRET_CAST(CTelObject*,CFaxDstdIden::NewL(FacPtr()));

	}

CTelObject* CCallDstdIden::OpenNewObjectL(TDes& /*aNewName*/)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject::TReqMode CCallDstdIden::ReqModeL(const TInt aIpc)

//

//	Basic Request Mode for Call

//

	{

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

	case EEtelCallRecoverDataPort:

	case EEtelCallAcquireOwnership:

		break;

	case EEtelCallNotifyStatusChange:

		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

	case EEtelCallNotifyHookChange:

		ret=KReqModeMultipleCompletionEnabled;

		break;

	case EEtelCallGetStatus:

	case EEtelCallGetCaps:

	case EEtelCallLoanDataPort:

	case EEtelCallDial:

	case EEtelCallConnect:

	case EEtelCallAnswer:

	case EEtelCallHangUp:

	case EEtelCallTransferOwnership:

	case EEtelCallGetBearerServiceInfo:

	case EEtelCallGetOwnershipStatus:

	case EEtelCallGetFaxSettings:

	case EEtelCallSetFaxSettings:

	case EEtelCallReferenceCount:

		ret=KReqModeFlowControlObeyed;

		break;

	default:

		User::Leave(0); // Server error = Should not call this

		break;

		}

	return ret;

	}

//

//	CFaxDstdIden

//

CFaxDstdIden* CFaxDstdIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CFaxDstdIden* fax=new(ELeave) CFaxDstdIden(aFac);

	CleanupStack::PushL(fax);

	fax->ConstructL();

	CleanupStack::Pop();

	return fax;

	}

CFaxDstdIden::CFaxDstdIden(CPhoneFactoryDummyBase* aFac)

	:CFaxDummyBase(aFac)

	{}

void CFaxDstdIden::ConstructL()

	{

	TInt r = iChunk.CreateGlobal(KNullDesC,sizeof (RFax::TProgress), sizeof (RFax::TProgress),EOwnerProcess); 

	if (r == KErrNone)

		{

		RFax::TProgress* progress = new(iChunk.Base()) RFax::TProgress;

		progress->iLastUpdateTime = 0;

		progress->iAnswerback.Zero ();

		progress->iPhase = ENotYetStarted;

		progress->iSpeed = 9600;

		progress->iResolution = EFaxNormal;

		progress->iCompression = EModifiedHuffman;

		progress->iECM = 0;

 		progress->iPage = 0;

		progress->iLines = 0;

		}	

	else

		User::Leave(r);

	}

CFaxDstdIden::~CFaxDstdIden()

	{

	iChunk.Close();

	}

RHandleBase* CFaxDstdIden::GlobalKernelObjectHandle()

	{

		return &iChunk;

	}

//

//	CLineDstdIden

//

CLineDstdIden* CLineDstdIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CLineDstdIden* line=new(ELeave) CLineDstdIden(aFac);

	CleanupStack::PushL(line);

	line->ConstructL();

	CleanupStack::Pop();

	return line;

	}

CLineDstdIden::CLineDstdIden(CPhoneFactoryDummyBase* aFac)

	:CLineDummyBase(aFac)

	{

	iFac=aFac;

	}

CLineDstdIden::~CLineDstdIden()

	{}

TInt CLineDstdIden::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aCount)

	{

	*aCount=iNumberOfCalls;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineDstdIden::GetCallInfo(const TTsyReqHandle aTsyReqHandle,TCallInfoIndex* aCallInfo)

	{

	aCallInfo->iInfo.iStatus=DSTD_CALL_STATUS;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineDstdIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CLineDstdIden::OpenNewObjectByNameL(const TDesC& /*aName*/)

	{

	return REINTERPRET_CAST(CTelObject*,CCallDstdIden::NewL(iFac));

	}

CTelObject* CLineDstdIden::OpenNewObjectL(TDes& aNewName)

	{

	aNewName.Append(DSTDIDEN_MODULE_NAME);

	aNewName.AppendNum(iNameIndex++);

	return REINTERPRET_CAST(CTelObject*,CCallDstdIden::NewL(iFac));

	}

//

//	CPhoneDstdIden

//

CPhoneDstdIden* CPhoneDstdIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CPhoneDstdIden* phone=new(ELeave) CPhoneDstdIden(aFac);

	CleanupStack::PushL(phone);

	phone->ConstructL();

	CleanupStack::Pop();

	return phone;

	}

CPhoneDstdIden::CPhoneDstdIden(CPhoneFactoryDummyBase* aFac)

	:CPhoneDummyBase(aFac)

	{}

CPhoneDstdIden::~CPhoneDstdIden()

	{}

TInt CPhoneDstdIden::EnumerateLines(const TTsyReqHandle aTsyReqHandle,TInt* aNumLines)

	{

	*aNumLines=DSTD_NUMBER_OF_LINES;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CPhoneDstdIden::GetLineInfo(const TTsyReqHandle aTsyReqHandle,TLineInfoIndex* aLineInfo)

	{

	if (aLineInfo->iIndex!=0)

		return(KErrArgument);

	aLineInfo->iInfo.iStatus=DSTD_LINE_STATUS;

	aLineInfo->iInfo.iName.Copy(DSTD_LINE_NAME);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

CTelObject::TReqMode CPhoneDstdIden::ReqModeL(const TInt aIpc)

//

//	Request Mode for Phone

//

	{

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

	case EEtelPhoneNotifyModemDetected:

		ret=KReqModeMultipleCompletionEnabled;

		break;

	case EEtelPhoneEnumerateLines:

	case EEtelPhoneGetLineInfo:

	case EEtelPhoneGetCaps:

	case EEtelPhoneGetStatus:

	case EEtelPhoneGetInfo:

		ret=KReqModeFlowControlObeyed;

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

TInt CPhoneDstdIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CPhoneDstdIden::OpenNewObjectByNameL(const TDesC& aName)

	{

	if (aName.Compare(DSTD_LINE_NAME)==KErrNone)

		return REINTERPRET_CAST(CTelObject*,CLineDstdIden::NewL(FacPtr()));

	return NULL;

	}

CTelObject* CPhoneDstdIden::OpenNewObjectL(TDes& /*aNewName*/)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

void CPhoneDstdIden::Init()

	{}

//

//	FlowControl	Phone

//

//

//	CFaxFcIden

//

CFaxFcIden* CFaxFcIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CFaxFcIden* fax=new(ELeave) CFaxFcIden(aFac);

	CleanupStack::PushL(fax);

	fax->ConstructL();

	CleanupStack::Pop();

	return fax;

	}

CFaxFcIden::CFaxFcIden(CPhoneFactoryDummyBase* aFac)

	:CFaxDummyBase(aFac)

	{}

void CFaxFcIden::ConstructL()

	{

	TInt r = iChunk.CreateGlobal(KNullDesC,sizeof (RFax::TProgress), sizeof (RFax::TProgress),EOwnerProcess); 

	if (r == KErrNone)

		{

		RFax::TProgress* progress = new(iChunk.Base()) RFax::TProgress;

		progress->iLastUpdateTime = 0;

		progress->iAnswerback.Zero ();

		progress->iPhase = ENotYetStarted;

		progress->iSpeed = 9600;

		progress->iResolution = EFaxNormal;

		progress->iCompression = EModifiedHuffman;

		progress->iECM = 0;

 		progress->iPage = 0;

		progress->iLines = 0;

		}	

else

		User::Leave(r);

	}

RHandleBase* CFaxFcIden::GlobalKernelObjectHandle()

	{

		return &iChunk;

	}

CFaxFcIden::~CFaxFcIden()

	{

	iChunk.Close();

	}

//

//	CCallFcIden

//

CCallFcIden* CCallFcIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CCallFcIden* call=new(ELeave) CCallFcIden(aFac);

	CleanupStack::PushL(call);

	call->ConstructL();

	CleanupStack::Pop();

	return call;

	}

CCallFcIden::CCallFcIden(CPhoneFactoryDummyBase* aFac)

	:CCallDummyBase(aFac)

	{}

CCallFcIden::~CCallFcIden()

	{}

TInt CCallFcIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CCallFcIden::OpenNewObjectByNameL(const TDesC& )

	{

	return REINTERPRET_CAST(CTelObject*,CFaxFcIden::NewL(FacPtr()));

	}

CTelObject* CCallFcIden::OpenNewObjectL(TDes& /*aNewName*/)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

//

//	CLineFcIden

//

CLineFcIden* CLineFcIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CLineFcIden* line=new(ELeave)CLineFcIden(aFac);

	CleanupStack::PushL(line);

	line->ConstructL();

	CleanupStack::Pop();

	return line;

	}

CLineFcIden::CLineFcIden(CPhoneFactoryDummyBase* aFac)

	:CLineDummyBase(aFac)

	{}

CLineFcIden::~CLineFcIden()

	{}

TInt CLineFcIden::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aCount)

	{

	*aCount=iNumberOfCalls;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineFcIden::GetCallInfo(const TTsyReqHandle aTsyReqHandle,TCallInfoIndex* aCallInfo)

	{

	aCallInfo->iInfo.iStatus=DSTDFC_CALL_STATUS;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineFcIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CLineFcIden::OpenNewObjectByNameL(const TDesC& aName)

	{

	if (aName.Compare(DSTDFC_CALL_NAME)==KErrNone)

		return REINTERPRET_CAST(CTelObject*,CCallFcIden::NewL(FacPtr()));

	return NULL;

	}

CTelObject* CLineFcIden::OpenNewObjectL(TDes& aNewName)

	{

	aNewName.Append(DSTDIDEN_MODULE_NAME);

	aNewName.AppendNum(iNameIndex++);

	return REINTERPRET_CAST(CTelObject*,CCallFcIden::NewL(FacPtr()));

	}

//

//	CPhoneFcIden

//

CPhoneFcIden* CPhoneFcIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CPhoneFcIden* phone=new(ELeave) CPhoneFcIden(aFac);

	CleanupStack::PushL(phone);

	phone->ConstructL();

	CleanupStack::Pop();

	return phone;

	}

CPhoneFcIden::CPhoneFcIden(CPhoneFactoryDummyBase* aFac)

	:CPhoneDummyBase(aFac)

	{}

void CPhoneFcIden::Init()

	{

	FlowControlSuspend();

	FacPtr()->QueueTimer(iOpenPhone,0,DSTDFC_OPEN_PHONE_TIMEOUT,CPhoneFcIden::OpenPhoneHandler,this);

	}

TInt CPhoneFcIden::OpenPhoneHandler(TAny* aPtr)

	{

	REINTERPRET_CAST(CPhoneFcIden*,aPtr)->FlowControlResume();

	REINTERPRET_CAST(CPhoneFcIden*,aPtr)->FacPtr()->ResetPending(REINTERPRET_CAST(CPhoneFcIden*,aPtr)->iOpenPhone );

	return KErrNone;

	}

CPhoneFcIden::~CPhoneFcIden()

	{

	FacPtr()->RemoveTimer(iOpenPhone);

	}

TInt CPhoneFcIden::EnumerateLines(const TTsyReqHandle aTsyReqHandle,TInt* aNumLines)

	{

	*aNumLines=DSTDFC_NUMBER_OF_LINES;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CPhoneFcIden::GetLineInfo(const TTsyReqHandle aTsyReqHandle,TLineInfoIndex* aLineInfo)

	{

	if (aLineInfo->iIndex!=0)

		return(KErrArgument);

	aLineInfo->iInfo.iStatus=DSTDFC_LINE_STATUS;

	aLineInfo->iInfo.iName.Copy(DSTDFC_LINE_NAME);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CPhoneFcIden::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)

	{

	return KErrNotSupported;

	}

CTelObject* CPhoneFcIden::OpenNewObjectByNameL(const TDesC& aName)

	{

	if (aName.Compare(DSTDFC_LINE_NAME)==KErrNone)

		return REINTERPRET_CAST(CTelObject*,CLineFcIden::NewL(FacPtr()));

	return NULL;

	}

CTelObject* CPhoneFcIden::OpenNewObjectL(TDes& /*aNewName*/)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

//

//	CFaxPmIden

//

CFaxPmIden* CFaxPmIden::NewL(CPhoneFactoryDummyBase* aFac)

	{

	CFaxPmIden* fax=new(ELeave) CFaxPmIden(aFac);

	CleanupStack::PushL(fax);

	fax->ConstructL();

	CleanupStack::Pop();

	return fax;

	}

CFaxPmIden::CFaxPmIden(CPhoneFactoryDummyBase* aFac)

	:CFaxDummyBase(aFac)

	{}

void CFaxPmIden::ConstructL()

	{

	TInt r = iChunk.CreateGlobal(KNullDesC,sizeof (RFax::TProgress), sizeof (RFax::TProgress),EOwnerProcess); 

	if (r == KErrNone)

		{

		RFax::TProgress* progress = new(iChunk.Base()) RFax::TProgress;

		progress->iLastUpdateTime = 0;

		progress->iAnswerback.Zero ();

		progress->iPhase = ENotYetStarted;

		progress->iSpeed = 9600;

		progress->iResolution = EFaxNormal;

		progress->iCompression = EModifiedHuffman;

		progress->iECM = 0;

 		progress->iPage = 0;

		progress->iLines = 0;

		}	

	else

		User::Leave(r);

	}