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

//

/**

 @file

*/

#include <f32file.h>

#include "ETELEXT.H"

#include "ETEL.H"

#include <et_clsvr.h>

#include "ET_STRUC.H"

#include "ETELPTR.H"

#include <rsshared.h>

#include <e32property.h>

#include <c32root.h>

#include <etelutils.h>

#include <et_struct.h>

#define NUM_FAXPTR		1

#define NUM_FAXPTRC		1

#define NUM_CALLPTR		6

#define NUM_CALLPTRC	3

#define NUM_LINEPTR		6

#define NUM_PHONEPTR	3

EXPORT_C void PanicClient(TInt aFault)

/**

Panics the client on client side.

@internalComponent

*/

	{

	_LIT(KETelClientFault,"Etel Client Fault");

	User::Panic(KETelClientFault,aFault);

	}

//

// RTelSubSessionBase

//

EXPORT_C RTelSubSessionBase::RTelSubSessionBase()

	:iTelSession(NULL)

	,iPtrHolder(NULL)

	{}

EXPORT_C TInt RTelSubSessionBase::CancelReq(const TInt aIpc,const TInt aIpcToCancel) const

//

//	Set up a cancel request before pass to server

//

/**

Sends a request to the ETel server/ TSY, to cancel a request.

@param aIpc The request, which may or may not be running, that should

            be cancelled.

@param aIpcToCancel Cancel IPC for the aIpc request.  This IPC is sent

                    to the server side as the cancel request.

@capability None

*/

	{

	__ASSERT_ALWAYS(aIpc!=aIpcToCancel,PanicClient(KErrArgument));

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	// The err variable should help in debugging, for example:

	//

	// 1) If an IPC does not exist (i.e. it has not been assigned a

	//    security policy) the server will return an error (for ETel

	//    IPC ranges KErrNotSupported is returned) and the cancel

	//    request will have no effect.

	//

	// 2) TSYs can decide to not accept an IPC, and thus, will return a

	//    chosen error code.

	//

	// 3) The client has not been assigned the capabilities it needs to

	//    use the cancel IPC (aIpcToCancel), thus, KErrPermissionDenied.

	//

	// For such cases, the err variable can help identify if the server

	// and client are behaving correctly.

	TInt err = SendReceive(aIpc,TIpcArgs(aIpcToCancel,EIsaCancelMessage));

	// TODO add logging code to display err as a Warning.

	return err;

	}

EXPORT_C TInt RTelSubSessionBase::CancelSubSession() const

//

//	Set up a cancel request before pass to server

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	return SendReceive(EEtelCancelSubSession,TIpcArgs(TIpcArgs::ENothing, EIsaCancelSubSession));

	}

EXPORT_C void RTelSubSessionBase::CancelAsyncRequest(TInt aReqToCancel) const

/**

Cancels a request of the specified IPC number.

@param aReqToCancel The IPC of a request that should be cancelled.  If

                    a request of this IPC is not currently outstanding

                    the TSY should decide what to do, but this usually

                    has no effect.

@capability None

*/

	{

	TInt cancelIpc;

	cancelIpc = aReqToCancel + EMobileCancelOffset;

	CancelReq(cancelIpc, aReqToCancel);

	}

EXPORT_C TInt RTelSubSessionBase::Blank(const TInt aIpc,TReqPriorityType aType) const

//

//	Set up a Null SYNC request before pass to server

//	There is no info passing between client/server

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set (0,TIpcArgs::ENothing);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaNull | KEmergencyClientReq));

	else

		args.Set(1,EIsaNull);

	return SendReceive(aIpc, args);

	}

EXPORT_C void RTelSubSessionBase::Blank(const TInt aIpc,TRequestStatus& aStatus,TReqPriorityType aType) const

//

//	Set up a Null ASYNC request before pass to server

//	There is no info passing between client/server

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,TIpcArgs::ENothing);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaNull | KEmergencyClientReq));

	else

		args.Set(1,(EIsaNull));

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C TInt RTelSubSessionBase::Set(const TInt aIpc,const TDesC8& aDes,TReqPriorityType aType) const

//

//	Set up a SYNCH. request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set (0, CONST_CAST(TDesC8*,&aDes));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaDesTobeSet);

	return SendReceive(aIpc, args);

	}

EXPORT_C void RTelSubSessionBase::Set(const TInt aIpc,TRequestStatus& aStatus,const TDesC8& aDes,TReqPriorityType aType) const

//

//	Set up a synch request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC8*,&aDes));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaDesTobeSet);

	SendReceive(aIpc,args,aStatus);

	//

	// Flush code...

	//

	SendReceive(EEtelFlushInterfaceQueue, TIpcArgs());

	}

EXPORT_C TInt RTelSubSessionBase::Get(const TInt aIpc,TDes8& aDes,TReqPriorityType aType) const

//

//	Set up an SYNC request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaDesTobeRead);

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Get(const TInt aIpc,TRequestStatus& aStatus,TDes8& aDes,TReqPriorityType aType) const

//

//	Set up an async request which the client provide a Des in p[0]

//	Server will write back data to client address space in aPtr

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaDesTobeRead);

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C void RTelSubSessionBase::Get(const TInt aIpc,TRequestStatus& aStatus,

								  TDes8& aDes1,TDes8& aDes2,TReqPriorityType aType) const

//

//	Set up a asynch request - server write data back into descriptors P0 and P2

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,EIsaDoubleDesTobeRead | KEmergencyClientReq);

	else

		args.Set(1,EIsaDoubleDesTobeRead);

	args.Set(2,&aDes2);

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C TInt RTelSubSessionBase::Get(const TInt aIpc,TDes8& aDes1,TDes8& aDes2,TReqPriorityType aType) const

//

//	Set up a synch request - server write data back into descriptors P0 and P2

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDoubleDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaDoubleDesTobeRead);

	args.Set(2,&aDes2);

	return SendReceive(aIpc,args);

	}

EXPORT_C TInt RTelSubSessionBase::Set(const TInt aIpc,const TDesC8& aDes1,const TDesC8& aDes2,TReqPriorityType aType) const

//

//	Set up a SYNCH. request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC8*,&aDes1));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDoubleDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaDoubleDesTobeSet);

	args.Set(2,CONST_CAST(TDesC8*,&aDes2));

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Set(const TInt aIpc,TRequestStatus& aStatus,const TDesC8& aDes1,

									const TDesC8& aDes2,TReqPriorityType aType) const

//

//	Set up a synch request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC8*,&aDes1));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaDoubleDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaDoubleDesTobeSet);

	args.Set(2,CONST_CAST(TDesC8*,&aDes2));

	SendReceive(aIpc,args,aStatus);

	//

	// Flush code...

	//

	SendReceive(EEtelFlushInterfaceQueue, TIpcArgs());

	}

EXPORT_C TInt RTelSubSessionBase::Set(const TInt aIpc,const TDesC16& aDes,TReqPriorityType aType) const

//

//	Set up a SYNCH. request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC16*,&aDes));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDesTobeSet);

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Set(const TInt aIpc,TRequestStatus& aStatus,const TDesC16& aDes,TReqPriorityType aType) const

//

//	Set up a synch request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC16*,&aDes));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDesTobeSet);

	SendReceive(aIpc,args,aStatus);

	//

	// Flush code...

	//

	SendReceive(EEtelFlushInterfaceQueue, TIpcArgs());

	}

EXPORT_C TInt RTelSubSessionBase::Get(const TInt aIpc,TDes16& aDes,TReqPriorityType aType) const

//

//	Set up an SYNC request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0, &aDes);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDesTobeRead);

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Get(const TInt aIpc,TRequestStatus& aStatus,TDes16& aDes,TReqPriorityType aType) const

//

//	Set up an async request which the client provide a Des in p[0]

//	Server will write back data to client address space in aPtr

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDesTobeRead);

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C void RTelSubSessionBase::Get(const TInt aIpc,TRequestStatus& aStatus,

								  TDes16& aDes1,TDes16& aDes2,TReqPriorityType aType) const

//

//	Set up a asynch request - server write data back into descriptors P0 and P2

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDoubleDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDoubleDesTobeRead);

	args.Set(2,&aDes2);

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C TInt RTelSubSessionBase::Get(const TInt aIpc,TDes16& aDes1,TDes16& aDes2,TReqPriorityType aType) const

//

//	Set up a synch request - server write data back into descriptors P0 and P2

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDoubleDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDoubleDesTobeRead);

	args.Set(2,&aDes2);

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Get(const TInt aIpc,TRequestStatus& aStatus,

								  TDes8& aDes1,TDes16& aDes2,TReqPriorityType aType) const

//

//	Set up a asynch request - server write data back into descriptors P0 and P2

//	P0 is a narrow descriptor, P2 is a unicode descriptor

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaNarrowAndUnicodeDoubleDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaNarrowAndUnicodeDoubleDesTobeRead);

	args.Set(2,&aDes2);

	SendReceive(aIpc,args,aStatus);

	}

EXPORT_C TInt RTelSubSessionBase::Get(const TInt aIpc,TDes8& aDes1,TDes16& aDes2,TReqPriorityType aType) const

//

//	Set up a synch request - server write data back into descriptors P0 and P2

//	P0 is a narrow descriptor, P2 is a unicode descriptor

//

/**

@capability None

*/

	{

	TIpcArgs args;

	args.Set(0,&aDes1);

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaNarrowAndUnicodeDoubleDesTobeRead | KEmergencyClientReq));

	else

		args.Set(1,EIsaNarrowAndUnicodeDoubleDesTobeRead);

	args.Set(2,&aDes2);

	return SendReceive(aIpc,args);

	}

EXPORT_C TInt RTelSubSessionBase::Set(const TInt aIpc,const TDesC16& aDes1,const TDesC16& aDes2,TReqPriorityType aType) const

//

//	Set up a SYNCH. request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC16*,&aDes1));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDoubleDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDoubleDesTobeSet);

	args.Set(2,CONST_CAST(TDesC16*,&aDes2));

	return SendReceive(aIpc,args);

	}

EXPORT_C void RTelSubSessionBase::Set(const TInt aIpc,TRequestStatus& aStatus,const TDesC16& aDes1,

									const TDesC16& aDes2,TReqPriorityType aType) const

//

//	Set up a synch request which the client provide a Des in p[0] for server to Set

//

/**

@capability None

*/

	{

	__ASSERT_ALWAYS(&(SessionHandle()),PanicClient(EEtelPanicNullHandle));

	TIpcArgs args;

	args.Set(0,CONST_CAST(TDesC16*,&aDes1));

	if (aType == EIsaEmergencyRequest || aType == EIsaPriorityRequest)

		args.Set(1,(EIsaUnicodeDoubleDesTobeSet | KEmergencyClientReq));

	else

		args.Set(1,EIsaUnicodeDoubleDesTobeSet);

	args.Set(2,CONST_CAST(TDesC16*,&aDes2));

	SendReceive(aIpc,args,aStatus);

	//

	// Flush code...

	//

	SendReceive(EEtelFlushInterfaceQueue, TIpcArgs());

	}