// 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 "DSTDNC.H"

#include "DNCDEF.H"

#include "../DSTD/DDEF.H"

#include "../TETEL/Tetelcs.h"

//

//	CFaxDstdNc

//

CFaxDstdNc* CFaxDstdNc::NewL(CPhoneFactoryDummyBase* aFac)

//

//	Create new instances of Fax

//

	{

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

	CleanupStack::PushL(fax);

	fax->ConstructL();

	CleanupStack::Pop();

	return fax;

	}

CFaxDstdNc::CFaxDstdNc(CPhoneFactoryDummyBase* aFac)

	:CFaxDummyBase(aFac)

	{}

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

	}

CFaxDstdNc::~CFaxDstdNc()

	{

	iChunk.Close();

	}

RHandleBase* CFaxDstdNc::GlobalKernelObjectHandle()

	{

	return &iChunk;

	}

//

//	CCallDstdNc

//

CCallDstdNc* CCallDstdNc::NewL(CPhoneFactoryDummyBase* aFac)

//

//	Static function to create new call

//

	{

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

	CleanupStack::PushL(call);

	call->ConstructL();

	CleanupStack::Pop();

	return call;

	}

CCallDstdNc::CCallDstdNc(CPhoneFactoryDummyBase* aFac)

	:CCallDummyBase(aFac)

	{}

void CCallDstdNc::ConstructL()

//

//	For future use

//

	{

	CCallDummyBase::ConstructL();

	iLoanCommPort=EFalse;

	}

CCallDstdNc::~CCallDstdNc()

	{

	}

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

//

//	not supported by the core tsy

//

	{

	return KErrNotSupported;

	}

CTelObject* CCallDstdNc::OpenNewObjectByNameL(const TDesC&)

//

//	open aFax within the context of a call

//

	{

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

	}

CTelObject* CCallDstdNc::OpenNewObjectL(TDes&)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

TInt CLineDstdNc::EnumerateCall(const TTsyReqHandle aUid,TInt* aCount)

	{

	*aCount=1;

	ReqCompleted(aUid,KErrNone);

	return KErrNone;

	}

TInt CLineDstdNc::GetCallInfo(const TTsyReqHandle aUid,TCallInfoIndex* aCallInfo)

	{

	aCallInfo->iInfo.iStatus=DSTDNC_CALL_STATUS;

	aCallInfo->iInfo.iCallCapsFlags=DSTDNC_CALL_CAPS;

	ReqCompleted(aUid,KErrNone);

	return KErrNone;

	}

//

//	CLineDstdNc

//

CLineDstdNc* CLineDstdNc::NewL(const TDesC&,CPhoneFactoryDummyBase* aFac)

//

//	Static Function for a New Line

//

	{

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

	CleanupStack::PushL(line);

	line->ConstructL();

	CleanupStack::Pop();

	return line;

	}

CLineDstdNc::CLineDstdNc(CPhoneFactoryDummyBase* aFac)

	:CLineDummyBase(aFac)

	{}

void CLineDstdNc::ConstructL()

	{}

CLineDstdNc::~CLineDstdNc()

	{}

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

//

//	Open subsession extension within context of a line

//

	{

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

		return REINTERPRET_CAST(CCallBase*,CCallDstdNc::NewL(FacPtr()));

	return NULL;

	}

CTelObject* CLineDstdNc::OpenNewObjectL(TDes& aNewName)

	{

	aNewName.Append(DSTDNC_MODULE_NAME);

	aNewName.AppendNum(iNameIndex++);

	return REINTERPRET_CAST(CCallBase*,CCallDstdNc::NewL(FacPtr()));

	}

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

//

//	not supported by the core tsy

//

	{

	return KErrNotSupported;

	}

//

//	CPhoneDstdNc

//

CPhoneDstdNc* CPhoneDstdNc::NewL(CPhoneFactoryDummyBase* aFac)

//

//	Create new phone

//

	{

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

	CleanupStack::PushL(phone);

	phone->ConstructL();

	CleanupStack::Pop();

	return phone;

	}

CPhoneDstdNc::CPhoneDstdNc(CPhoneFactoryDummyBase* aFac)

	:CPhoneDummyBase(aFac)

	{}

void CPhoneDstdNc::ConstructL()

	{}

CPhoneDstdNc::~CPhoneDstdNc()

	{}

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

	{

	*aNumLines=DSTDNC_NUMBER_OF_LINES;	//	just	one	line	on	this	phone

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

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

	{

	if (aLineInfo->iIndex!=0)

		return(KErrArgument);

	aLineInfo->iInfo.iStatus=DSTDNC_LINE_STATUS;

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

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

CTelObject::TReqMode CPhoneDstdNc::ReqModeL(const TInt)

//

//	Request Mode for Phone

//

	{

	CTelObject::TReqMode ret=0;

	return ret;

	}

TInt CPhoneDstdNc::ExtFunc(const TTsyReqHandle aTsyReqHandle, const TInt aIpc, const TDataPackage&)

	{

	switch(aIpc)

		{

	//Only CustomIPC2 is supported by this TSY.

	case ETestCustomIPC2: //IPC 9056

		ReqCompleted(aTsyReqHandle,KErrNone);

		return KErrNone;

	//Custom IPCs 1,3,4,5,6,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 ETestCustomIPC1: //IPC 1000055 - No support for this IPC in this TSY

	case ETestCustomIPC6: //IPC 1000500 - No support for this IPC in this TSY

	case ETestCustomIPC3: //IPC 1000099 - No support for this IPC in this TSY

	case ETestCustomIPC4: //IPC 1000100 - Should never be supported by a TSY as IPC is outside allocated range

	case ETestCustomIPC5: //IPC 1000499 - Should never be supported by a TSY as IPC is outside allocated range

	case ETestCustomIPC7: //IPC 1000099 - No support for this IPC in this TSY

	case ETestCustomIPC8: //IPC 1000600 - 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* CPhoneDstdNc::OpenNewObjectByNameL(const TDesC& aName)

//

//	Open New Line within the Context of a Phone

//

	{

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

		return REINTERPRET_CAST(CTelObject*,CLineDstdNc::NewL(aName,FacPtr()));

	return NULL;

	}

CTelObject* CPhoneDstdNc::OpenNewObjectL(TDes&)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

void CPhoneDstdNc::Init()

	{}

TSecurityPolicy CPhoneDstdNc::GetRequiredPlatSecCaps(const TInt aIpc)

	{

	switch(aIpc)

		{

	case ETestCustomIPC2:

		return TSecurityPolicy(ECapabilityReadUserData);

	case ETestCustomIPC1: //Not supported by this TSY

	case ETestCustomIPC6: //Not supported by this TSY	

	case ETestCustomIPC3: //Not supported by this TSY

	case ETestCustomIPC4: //Not in range of IPCs allocated to Custom IPCs should be caught by Etel's policy table

	case ETestCustomIPC5: //Not in range of IPCs allocated to Custom IPCs should be caught by Etel's policy table

	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);

		}

	}	

//

// DSTDNC Phone Factory Functions

//

CPhoneFactoryDstdNc* CPhoneFactoryDstdNc::NewL()

	{

	CPhoneFactoryDstdNc *This = new (ELeave) CPhoneFactoryDstdNc;

	CleanupStack::PushL(This);

	This->ConstructL();

	CleanupStack::Pop();

	return This;

	}

CPhoneFactoryDstdNc::CPhoneFactoryDstdNc()

//

//	Constructor for Phone Factory

//

	{

	iVersion=TVersion(	KTsyEtelMajorVersionNumber,

						KTsyEtelMinorVersionNumber,

						KTsyEtelBuildVersionNumber);

	}

CPhoneFactoryDstdNc::~CPhoneFactoryDstdNc()

//

//	D'tor

//

	{

	}

CPhoneBase* CPhoneFactoryDstdNc::NewPhoneL(const TDesC& aName)

//

//	Create New Instance of Phone

//

	{

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

		return CPhoneDstdNc::NewL(this);

	return NULL;

	}

TInt CPhoneFactoryDstdNc::GetPhoneInfo(const TInt aIndex, RTelServer::TPhoneInfo& aInfo)

//

//	Get Phone Info

//

	{

	switch (aIndex)

		{

	case 0:

		aInfo.iNetworkType=DSTDNC_NETWORK_TYPE;

		aInfo.iName=DSTDNC_PHONE_NAME;

		aInfo.iNumberOfLines=DSTDNC_NUMBER_OF_LINES;

		return KErrNone;

	default:

		return KErrNotFound;

		}

	}

TInt CPhoneFactoryDstdNc::EnumeratePhones()

	{

	return (DSTDNC_NUMBER_OF_PHONES);

	}

//

// First Ordinal Functions

//

extern "C"

	{

	IMPORT_C CPhoneFactoryBase* LibEntry();	// Force "Proper Name" export

	}

EXPORT_C CPhoneFactoryBase* LibEntry()

	{

	CPhoneFactoryDstdNc* factory = NULL;

	TRAP_IGNORE(factory = CPhoneFactoryDstdNc::NewL());

	return factory;

	}