// 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 "DSTD.H"
#include "DDEF.H"
#include "../TETEL/Tetelcs.h"

//
// CCallDstd
//
CCallDstd* CCallDstd::NewL(CPhoneFactoryDummyBase* aFac)
//
// Create new instance of CCallDstd
//
	{
	CCallDstd* call=new(ELeave)CCallDstd(aFac);
	CleanupStack::PushL(call);
	call->ConstructL();
	CleanupStack::Pop();
	return call;
	}

CCallDstd::CCallDstd(CPhoneFactoryDummyBase* aFac)
	:CCallDummyBase(aFac)
	{}

CCallDstd::~CCallDstd()
	{}

TInt CCallDstd::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CCallDstd::OpenNewObjectByNameL(const TDesC& /*aName*/)
	{
	return REINTERPRET_CAST(CTelObject*,CFaxDstd::NewL(FacPtr()));
	}

CTelObject* CCallDstd::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

CTelObject::TReqMode CCallDstd::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:
	case EEtelAdoptFaxSharedHeaderFile:
		ret=KReqModeFlowControlObeyed;
		break;
	default:
		User::Leave(0); // Server error = Should not call this
		break;
		}
	return ret;
	}



	
//
//	CFaxDstd
//
CFaxDstd* CFaxDstd::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CFaxDstd* fax=new(ELeave) CFaxDstd(aFac);
	CleanupStack::PushL(fax);
	fax->ConstructL();
	CleanupStack::Pop();
	return fax;
	}

CFaxDstd::CFaxDstd(CPhoneFactoryDummyBase* aFac)
	:CFaxDummyBase(aFac)
	{}

void CFaxDstd::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);
	}

CFaxDstd::~CFaxDstd()
	{
	iChunk.Close();
	}

RHandleBase* CFaxDstd::GlobalKernelObjectHandle()
	{	
	return &iChunk;
	}


//
//	CLineDstd
//
CLineDstd* CLineDstd::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CLineDstd* line=new(ELeave) CLineDstd(aFac);
	CleanupStack::PushL(line);
	line->ConstructL();
	CleanupStack::Pop();
	return line;
	}

CLineDstd::CLineDstd(CPhoneFactoryDummyBase* aFac)
	:CLineDummyBase(aFac)
	{
	iFac=aFac;
	}

CLineDstd::~CLineDstd()
	{}

TInt CLineDstd::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aCount)
	{
	*aCount=iNumberOfCalls;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CLineDstd::GetCallInfo(const TTsyReqHandle aTsyReqHandle,TCallInfoIndex* aCallInfo)
	{
	aCallInfo->iInfo.iStatus=DSTD_CALL_STATUS;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CLineDstd::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CLineDstd::OpenNewObjectByNameL(const TDesC& /*aName*/)
	{
	return REINTERPRET_CAST(CTelObject*,CCallDstd::NewL(iFac));
	}

CTelObject* CLineDstd::OpenNewObjectL(TDes& aNewName)
	{
	aNewName.Append(DSTD_MODULE_NAME);
	aNewName.AppendNum(iNameIndex++);
	return REINTERPRET_CAST(CTelObject*,CCallDstd::NewL(iFac));
	}

//
//	CPhoneDstd
//
CPhoneDstd* CPhoneDstd::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CPhoneDstd* phone=new(ELeave) CPhoneDstd(aFac);
	CleanupStack::PushL(phone);
	phone->ConstructL();
	CleanupStack::Pop();
	return phone;
	}

CPhoneDstd::CPhoneDstd(CPhoneFactoryDummyBase* aFac)
	:CPhoneDummyBase(aFac)
	{}

CPhoneDstd::~CPhoneDstd()
	{}

TInt CPhoneDstd::EnumerateLines(const TTsyReqHandle aTsyReqHandle,TInt* aNumLines)
	{
	*aNumLines=DSTD_NUMBER_OF_LINES;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CPhoneDstd::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 CPhoneDstd::ReqModeL(const TInt aIpc)
//
//	Request Mode for Phone
//
	{
	CTelObject::TReqMode ret=0;
	switch (aIpc)
		{
	case ETestCustomIPC1:
	case ETestCustomIPC2:
	case ETestCustomIPC3:
	case ETestCustomIPC4:
	case ETestCustomIPC5:
	case ETestCustomIPC6:
	case ETestCustomIPC7:
	case ETestCustomIPC8:
	case ETestCustomIPC9:
		break;
	case EEtelPhoneNotifyModemDetected:
		ret=KReqModeMultipleCompletionEnabled;
		break;
	case EEtelPhoneEnumerateLines:
	case EEtelPhoneGetLineInfo:
	case EEtelPhoneGetCaps:
	case EEtelPhoneGetStatus:
	case EEtelPhoneGetInfo:
	case ETestEtelUnicodeSetAndNarrowGet:
	case ETestEtelNarrowSetAndGet:
	case ETestEtelNarrowSetAndUnicodeGet:
	case ETestEtelUnicodeSetAndGet:
	case ETestEtelDoubleUnicodeGet:
	case EETelPhoneSetEmergencyClient:
		ret=KReqModeFlowControlObeyed;
		break;
	default:
		User::Leave(KErrNotSupported);
		break;
		}
	return ret;

	}

TInt CPhoneDstd::ExtFunc(const TTsyReqHandle aTsyReqHandle, const TInt aIpc, const TDataPackage& aPackage)
	{

	switch (aIpc)
		{
	case ETestEtelNarrowSetAndGet:
		return TestNarrowSetAndGet(aTsyReqHandle, aPackage.Des1n(),aPackage.Des2n());
			
	case ETestEtelUnicodeSetAndNarrowGet:
		return TestUnicodeSetAndNarrowGet(aTsyReqHandle, aPackage.Des1n(),aPackage.Des2u());
	
	case ETestEtelUnicodeSetAndGet:
		return TestUnicodeSetAndGet(aTsyReqHandle, aPackage.Des1u(),aPackage.Des2u());
			
	case ETestEtelNarrowSetAndUnicodeGet:
		return TestNarrowSetAndUnicodeGet(aTsyReqHandle, aPackage.Des1n(),aPackage.Des2u());
		
	case ETestEtelDoubleUnicodeGet:
	    return TestDoubleUnicodeGet(aTsyReqHandle, aPackage.Des1u(), aPackage.Des2u());
	    
	//Custom IPC 1,2 &6 are supported by this TSY.
	case ETestCustomIPC1: //IPC 1000055
	case ETestCustomIPC2: //IPC 1000056
		ReqCompleted(aTsyReqHandle,KErrNone);
		return KErrNone;
	
	case EETelPhoneSetEmergencyClient:
		ReqCompleted(aTsyReqHandle,KErrNone);
		return KErrNone;

	case ETestCustomIPC6:
		return KErrCancel; //IPC 100500 (potentially a cancel request for IPC 9000)

	//Custom IPCs 3,4,5,7,8 & 9 are not supported for various reasons.
	//Typically a TSY will not explicitly list the IPCs it does not support but they are listed
	//here for clarity
	case ETestCustomIPC3: //IPC 1000099 - No support for this IPC in this TSY
	case ETestCustomIPC4: //IPC 1000100 - No support for this IPC in this TSY
	case ETestCustomIPC5: //IPC 1000499 - No support for this IPC in this TSY
	case ETestCustomIPC7: //IPC 1000099 - No support for this IPC in this TSY
	case ETestCustomIPC8: //IPC 1001000 - Should never be supported by a TSY as IPC is outside allocated range
	case ETestCustomIPC9: //IPC 999999  - Should never be supported by a TSY as IPC is outside allocated range
		return KErrNotSupported;
		}

	return KErrNotSupported;
	}

CTelObject* CPhoneDstd::OpenNewObjectByNameL(const TDesC& aName)
	{
	if (aName.Compare(DSTD_LINE_NAME)==KErrNone)
		return REINTERPRET_CAST(CTelObject*,CLineDstd::NewL(FacPtr()));
	return NULL;
	}

CTelObject* CPhoneDstd::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

void CPhoneDstd::Init()
	{}


TInt CPhoneDstd::TestNarrowSetAndGet(const TTsyReqHandle aTsyReqHandle, const TDesC8* aDes1, TDes8* aDes2)
	{
	if (aDes1->Compare(DSTD_NARROW)!=KErrNone)
		{
		TInt  extendedError = (KErrLicenseeSpecificCorrupt << 16) |
			                  (KErrCorrupt & 0x0000ffff);
		
		ReqCompleted(aTsyReqHandle,extendedError);
		}
	else
		{
		TInt  extendedError = (KErrLicenseeSpecificOkay << 16) |
			                  (KErrNone & 0x0000ffff);
		
		*aDes2=DSTD_NARROW;
		ReqCompleted(aTsyReqHandle,extendedError);
		}
	return KErrNone;	
	}

TInt CPhoneDstd::TestUnicodeSetAndNarrowGet(const TTsyReqHandle aTsyReqHandle, TDes8* aDes1, const TDesC16* aDes2)
	{
	if (aDes2->Compare(DSTD_UNICODE)!=KErrNone)
		ReqCompleted(aTsyReqHandle,KErrCorrupt);
	else
		{
		*aDes1=DSTD_NARROW;
		ReqCompleted(aTsyReqHandle,KErrNone);
		}
	return KErrNone;	
	}

TInt CPhoneDstd::TestUnicodeSetAndGet(const TTsyReqHandle aTsyReqHandle, const TDesC16* aDes1, TDes16* aDes2)
	{
	if (aDes1->Compare(DSTD_UNICODE)!=KErrNone)
		ReqCompleted(aTsyReqHandle,KErrCorrupt);
	else
		{
		*aDes2=DSTD_UNICODE;
		ReqCompleted(aTsyReqHandle,KErrNone);
		}
	return KErrNone;	
	}

TInt CPhoneDstd::TestNarrowSetAndUnicodeGet(const TTsyReqHandle aTsyReqHandle, const TDesC8* aDes1 , TDes16* aDes2)
	{
	if (aDes1->Compare(DSTD_NARROW)!=KErrNone)
		ReqCompleted(aTsyReqHandle,KErrCorrupt);
	else
		{
		*aDes2=DSTD_UNICODE;
		ReqCompleted(aTsyReqHandle,KErrNone);
		}
	return KErrNone;	
	}

TInt CPhoneDstd::TestDoubleUnicodeGet(const TTsyReqHandle aTsyReqHandle, TDes16* aDes1 , TDes16* aDes2)
    {
    *aDes1=DSTD_UNICODE;
    *aDes2=DSTD_UNICODE;
    ReqCompleted(aTsyReqHandle,KErrNone);

    return KErrNone;    
    }

TSecurityPolicy CPhoneDstd::GetRequiredPlatSecCaps(const TInt aIpc)
	{
	switch(aIpc)
		{
	case ETestCustomIPC1:
		return TSecurityPolicy(ECapabilityNetworkServices);

	case ETestCustomIPC2:
		return TSecurityPolicy(ECapabilityTCB);

	case ETestCustomIPC6:
		return TSecurityPolicy(ECapabilityReadUserData, ECapabilityWriteUserData);

	case ETestCustomIPC3: //Not supported by this TSY
	case ETestCustomIPC4: //Not supported by this TSY
	case ETestCustomIPC5: //Not supported by this TSY
	case ETestCustomIPC7: //Not supported by this TSY
	case ETestCustomIPC8: //Not in range of IPCs allocated to Custom IPCs should be caught by Etel's policy table
	case ETestCustomIPC9: //Not in range of IPCs allocated to Custom IPCs should be caught by Etel's policy table
		return TSecurityPolicy(TSecurityPolicy::EAlwaysFail);

	default:
		//For any non-Custom IPCs return a policy that will always cause the capability check to pass
		return TSecurityPolicy(TSecurityPolicy::EAlwaysPass);
		}
	}	

//
//	FlowControl	Phone
//

//
//	CFaxFc
//
CFaxFc* CFaxFc::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CFaxFc* fax=new(ELeave) CFaxFc(aFac);
	CleanupStack::PushL(fax);
	fax->ConstructL();
	CleanupStack::Pop();
	return fax;
	}

CFaxFc::CFaxFc(CPhoneFactoryDummyBase* aFac)
	:CFaxDummyBase(aFac)
	{}

void CFaxFc::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);
	}

CFaxFc::~CFaxFc()
	{
	iChunk.Close();
	}

RHandleBase* CFaxFc::GlobalKernelObjectHandle()
	{		
	return &iChunk;
	}

//
//	CCallFc
//
CCallFc* CCallFc::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CCallFc* call=new(ELeave) CCallFc(aFac);
	CleanupStack::PushL(call);
	call->ConstructL();
	CleanupStack::Pop();
	return call;
	}

CCallFc::CCallFc(CPhoneFactoryDummyBase* aFac)
	:CCallDummyBase(aFac)
	{}

CCallFc::~CCallFc()
	{}



TInt CCallFc::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CCallFc::OpenNewObjectByNameL(const TDesC& )
	{
	return REINTERPRET_CAST(CTelObject*,CFaxFc::NewL(FacPtr()));
	}

CTelObject* CCallFc::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

//
//	CLineFc
//
CLineFc* CLineFc::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CLineFc* line=new(ELeave)CLineFc(aFac);
	CleanupStack::PushL(line);
	line->ConstructL();
	CleanupStack::Pop();
	return line;
	}

CLineFc::CLineFc(CPhoneFactoryDummyBase* aFac)
	:CLineDummyBase(aFac)
	{}

CLineFc::~CLineFc()
	{}

TInt CLineFc::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aCount)
	{
	*aCount=iNumberOfCalls;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CLineFc::GetCallInfo(const TTsyReqHandle aTsyReqHandle,TCallInfoIndex* aCallInfo)
	{
	aCallInfo->iInfo.iStatus=DSTDFC_CALL_STATUS;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CLineFc::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CLineFc::OpenNewObjectByNameL(const TDesC& aName)
	{
	if (aName.Compare(DSTDFC_CALL_NAME)==KErrNone)
		return REINTERPRET_CAST(CTelObject*,CCallFc::NewL(FacPtr()));
	return NULL;
	}

CTelObject* CLineFc::OpenNewObjectL(TDes& aNewName)
	{
	aNewName.Append(DSTD_MODULE_NAME);
	aNewName.AppendNum(iNameIndex++);
	return REINTERPRET_CAST(CTelObject*,CCallFc::NewL(FacPtr()));
	}

//
//	CPhoneFc
//
CPhoneFc* CPhoneFc::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CPhoneFc* phone=new(ELeave) CPhoneFc(aFac);
	CleanupStack::PushL(phone);
	phone->ConstructL();
	CleanupStack::Pop();
	return phone;
	}

CPhoneFc::CPhoneFc(CPhoneFactoryDummyBase* aFac)
	:CPhoneDummyBase(aFac)
	{}

void CPhoneFc::Init()
	{
	FlowControlSuspend();
	FacPtr()->QueueTimer(iOpenPhone,0,DSTDFC_OPEN_PHONE_TIMEOUT,CPhoneFc::OpenPhoneHandler,this);
	}

TInt CPhoneFc::OpenPhoneHandler(TAny* aPtr)
	{
	REINTERPRET_CAST(CPhoneFc*,aPtr)->FlowControlResume();
	REINTERPRET_CAST(CPhoneFc*,aPtr)->FacPtr()->ResetPending(REINTERPRET_CAST(CPhoneFc*,aPtr)->iOpenPhone );
	return KErrNone;
	}

CPhoneFc::~CPhoneFc()
	{
	FacPtr()->RemoveTimer(iOpenPhone);
	}

TInt CPhoneFc::EnumerateLines(const TTsyReqHandle aTsyReqHandle,TInt* aNumLines)
	{
	*aNumLines=DSTDFC_NUMBER_OF_LINES;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CPhoneFc::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 CPhoneFc::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CPhoneFc::OpenNewObjectByNameL(const TDesC& aName)
	{
	if (aName.Compare(DSTDFC_LINE_NAME)==KErrNone)
		return REINTERPRET_CAST(CTelObject*,CLineFc::NewL(FacPtr()));
	return NULL;
	}

CTelObject* CPhoneFc::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

//
//	CFaxPm
//
CFaxPm* CFaxPm::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CFaxPm* fax=new(ELeave) CFaxPm(aFac);
	CleanupStack::PushL(fax);
	fax->ConstructL();	
	CleanupStack::Pop();
	return fax;
	}

CFaxPm::CFaxPm(CPhoneFactoryDummyBase* aFac)
	:CFaxDummyBase(aFac)
	{}

void CFaxPm::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);
	}

CFaxPm::~CFaxPm()
	{
	iChunk.Close();
	}
	
RHandleBase* CFaxPm::GlobalKernelObjectHandle()
	{	
	return &iChunk;
	}


//
//	CCallPm
//
CCallPm* CCallPm::NewL(TInt& aNumberOfCalls,CPhoneFactoryDummyBase* aFac)
	{
	CCallPm* call=new(ELeave) CCallPm(aNumberOfCalls,aFac);
	CleanupStack::PushL(call);
	call->ConstructL();
	CleanupStack::Pop();
	return call;
	}

CCallPm::CCallPm(TInt& aNumberOfCalls,CPhoneFactoryDummyBase* aFac)
	: CCallDummyBase(aFac),
	iNumberOfCalls(aNumberOfCalls)
	{}

CCallPm::~CCallPm()
	{
	iNumberOfCalls--;
	}

TInt CCallPm::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CCallPm::OpenNewObjectByNameL(const TDesC& )
	{
	return REINTERPRET_CAST(CTelObject*,CFaxPm::NewL(FacPtr()));
	}
CTelObject* CCallPm::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}


//
//	CLinePm
//
CLinePm* CLinePm::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CLinePm* line=new(ELeave) CLinePm(aFac);
	CleanupStack::PushL(line);
	line->ConstructL();
	CleanupStack::Pop();
	return line;
	}

CLinePm::CLinePm(CPhoneFactoryDummyBase* aFac)
	:CLineDummyBase(aFac)
	{}

void CLinePm::ConstructL()
	{
	CLineDummyBase::ConstructL();
	iNumberOfCalls=0;
	iCallName.SetLength(0);
	}

CLinePm::~CLinePm()
	{}

TInt CLinePm::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aCount)
	{
	*aCount=iNumberOfCalls;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CLinePm::GetCallInfo(const TTsyReqHandle aUid,TCallInfoIndex* aCallInfo)
	{
	aCallInfo->iInfo.iStatus=	DSTDPM_CALL_STATUS;
	aCallInfo->iInfo.iCallName.Copy(iCallName);

	ReqCompleted(aUid,KErrNone);
	return KErrNone;
	}

TInt CLinePm::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CLinePm::OpenNewObjectByNameL(const TDesC& aName)
	{
	iNumberOfCalls++;
	iCallName.Copy(aName);
	return REINTERPRET_CAST(CTelObject*,CCallPm::NewL(iNumberOfCalls,FacPtr()));
	}
CTelObject* CLinePm::OpenNewObjectL(TDes& aNewName)
	{
	iNumberOfCalls++;
	aNewName.Append(DSTD_MODULE_NAME);
	aNewName.AppendNum(iNameIndex++);
	iCallName.Copy(aNewName);
	return REINTERPRET_CAST(CTelObject*,CCallPm::NewL(iNumberOfCalls,FacPtr()));
	}

//
//	CPhonePm
//
CPhonePm* CPhonePm::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CPhonePm* phone=new(ELeave) CPhonePm(aFac);
	CleanupStack::PushL(phone);
	phone->ConstructL();
	CleanupStack::Pop();
	return phone;
	}

CPhonePm::CPhonePm(CPhoneFactoryDummyBase* aFac)
	:CPhoneDummyBase(aFac)
	{}

void CPhonePm::Init()
	{}

CPhonePm::~CPhonePm()
	{}

TInt CPhonePm::EnumerateLines(const TTsyReqHandle aTsyReqHandle,TInt* aNumLines)
	{
	*aNumLines=DSTDPM_NUMBER_OF_LINES;
	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CPhonePm::GetLineInfo(const TTsyReqHandle aTsyReqHandle,TLineInfoIndex* aLineInfo)
	{
	if (aLineInfo->iIndex!=0)
		return(KErrArgument);

	aLineInfo->iInfo.iStatus=DSTDPM_LINE_STATUS;
	aLineInfo->iInfo.iName.Copy(DSTDPM_LINE_NAME);

	ReqCompleted(aTsyReqHandle,KErrNone);
	return KErrNone;
	}

TInt CPhonePm::ExtFunc(const TTsyReqHandle,const TInt,const TDataPackage&)
	{
	return KErrNotSupported;
	}

CTelObject* CPhonePm::OpenNewObjectByNameL(const TDesC& aName)
	{
	if (aName.Compare(DSTDPM_LINE_NAME)==KErrNone)
		return REINTERPRET_CAST(CTelObject*,CLinePm::NewL(FacPtr()));
	return NULL;
	}
CTelObject* CPhonePm::OpenNewObjectL(TDes& /*aNewName*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

//
//	First Ordinal Functions
//
extern	"C"
	{
	IMPORT_C CPhoneFactoryBase* LibEntry();	//	Force "Proper Name" export
	}

void CPhoneFactoryDstd::CloseObj(TAny* aObj)
/**
*	A utility function for cleaning up the stack.
*
* @param aObj a pointer to the CObject to close
*/
	{
	((CObject*)aObj)->Close();
	}

EXPORT_C CPhoneFactoryBase* LibEntry()
	{
	CPhoneFactoryDstd* factory = NULL;
	TRAP_IGNORE(factory = CPhoneFactoryDstd::NewL());
	return factory;
	}

//
//	DSTD Phone	Factory	Functions
//

CPhoneFactoryDstd* CPhoneFactoryDstd::NewL()
	{
	CPhoneFactoryDstd *phoneFac = new (ELeave) CPhoneFactoryDstd;
	TCleanupItem newPhoneFacClose(CloseObj,phoneFac);
	CleanupStack::PushL(newPhoneFacClose);
	phoneFac->ConstructL();
	CleanupStack::Pop();
	return phoneFac;
	}

CPhoneFactoryDstd::CPhoneFactoryDstd()
	{
	iVersion=TVersion(	KTsyEtelMajorVersionNumber,
						KTsyEtelMinorVersionNumber,
						KTsyEtelBuildVersionNumber);
	}

CPhoneFactoryDstd::~CPhoneFactoryDstd()
	{}

CPhoneBase* CPhoneFactoryDstd::NewPhoneL(const TDesC& aName)
	{
	if (aName.Compare(DSTD_PHONE_NAME)==KErrNone)
		return CPhoneDstd::NewL(this);
	if (aName.Compare(DSTDFC_PHONE_NAME)==KErrNone)
		return CPhoneFc::NewL(this);
	if (aName.Compare(DSTDPM_PHONE_NAME)==KErrNone)
		return CPhonePm::NewL(this);
	if (aName.Compare(DSTD_SLOW_PHONE_NAME)==KErrNone)
		return CPhoneDstdSlow::NewL(this);
	return NULL;
	}

TInt CPhoneFactoryDstd::GetPhoneInfo(const TInt aIndex,RTelServer::TPhoneInfo& aInfo)
	{
	switch(aIndex)
		{
	case 0:
		aInfo.iNetworkType=DSTD_NETWORK_TYPE;
		aInfo.iName=DSTD_PHONE_NAME;
		aInfo.iNumberOfLines=DSTD_NUMBER_OF_LINES;
		return KErrNone;
	case 1:
		aInfo.iNetworkType=DSTDFC_NETWORK_TYPE;
		aInfo.iName=DSTDFC_PHONE_NAME;
		aInfo.iNumberOfLines=DSTDFC_NUMBER_OF_LINES;
		return KErrNone;
	case 2:
		aInfo.iNetworkType=DSTDPM_NETWORK_TYPE;
		aInfo.iName=DSTDPM_PHONE_NAME;
		aInfo.iNumberOfLines=DSTDPM_NUMBER_OF_LINES;
		return KErrNone;
	case 3:
		aInfo.iNetworkType=DSTDPM_NETWORK_TYPE;
		aInfo.iName=DSTD_SLOW_PHONE_NAME;
		aInfo.iNumberOfLines=DSTDPM_NUMBER_OF_LINES;
		return KErrNone;
	default:
		return KErrNotFound;
		}
	}

TInt CPhoneFactoryDstd::EnumeratePhones()
	{
	TVersion version(KTsyEtelMajorVersionNumber,
					KTsyEtelMinorVersionNumber,
					KTsyEtelBuildVersionNumber);
	if (!QueryVersionSupported(version))
		return(KErrNotSupported);

	return (DSTD_NUMBER_OF_PHONES);
	}


//
//	CPhoneDstdSlow
//
CPhoneDstdSlow* CPhoneDstdSlow::NewL(CPhoneFactoryDummyBase* aFac)
	{
	CPhoneDstdSlow* phone=new(ELeave) CPhoneDstdSlow(aFac);
	CleanupStack::PushL(phone);
	phone->ConstructL();
	CleanupStack::Pop();
	return phone;
	}

CPhoneDstdSlow::CPhoneDstdSlow(CPhoneFactoryDummyBase* aFac)
	:CPhoneDstd(aFac)
	{}

CPhoneDstdSlow::~CPhoneDstdSlow()
	{}

TInt CPhoneDstdSlow::GetLineInfo(const TTsyReqHandle aTsyReqHandle,TLineInfoIndex* aLineInfo)
	{
	User::After(1000);
	return CPhoneDstd::GetLineInfo(aTsyReqHandle,aLineInfo);
	}