/*

* Copyright (c) 2005 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 "mcecsserveritc.h"

#include "mceserver.pan"

#include "mcelogs.h"

const TInt KInt0 = 0;

const TInt KInt1 = 1;

const TInt KInt2 = 2;

const TInt KInt3 = 3;

// -----------------------------------------------------------------------------

// CMceCsServerITC::NewL

// -----------------------------------------------------------------------------

//

CMceCsServerITC* CMceCsServerITC::NewL ()

	{

    CMceCsServerITC* self = CMceCsServerITC::NewLC ();

    CleanupStack::Pop(self);

    return self;

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::NewLC

// -----------------------------------------------------------------------------

//

CMceCsServerITC* CMceCsServerITC::NewLC ()

	{

    CMceCsServerITC* self = new (ELeave) CMceCsServerITC;

    CleanupStack::PushL (self);

    return self;

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::CMceCsServerITC

// -----------------------------------------------------------------------------

//

CMceCsServerITC::CMceCsServerITC ()

	{

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::~CMceCsServerITC

// -----------------------------------------------------------------------------

//

CMceCsServerITC::~CMceCsServerITC ()

	{

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::WriteL

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::WriteL (const RMessage2& aMessage,

                              const TDesC8& aDes,

                              TMceItcArguments aItcArgIndex) const

    {

    WriteL (aItcArgIndex,aMessage,aDes);

    }

// -----------------------------------------------------------------------------

// CMceCsServerITC::WriteL

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::WriteL (const RMessage2& aMessage,

                              const TMceIds& aIds) const

	{

    TPckgBuf<TMceIds> mceIdsPckg(aIds);

    WriteL (EMceItcArgIds, aMessage, mceIdsPckg);

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::WriteL

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::WriteL (const RMessage2& aMessage,

                              const TMceMessageBufSizes aSizes) const

    {

    TPckgBuf<TMceMessageBufSizes> bufSizesPckg(aSizes);

    WriteL (EMceItcArgBufSizes, aMessage, bufSizesPckg);

    }

// -----------------------------------------------------------------------------

// CMceCsServerITC::ReadMCEIdsL

// -----------------------------------------------------------------------------

//

TMceIds CMceCsServerITC::ReadMCEIdsL (const RMessage2& aMessage) const

	{

    TPckgBuf<TMceIds> mceIdsPckg;

    aMessage.ReadL (EMceItcArgIds, mceIdsPckg);

    return mceIdsPckg();

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ReadTUint32L

// -----------------------------------------------------------------------------

//

TUint32 CMceCsServerITC::ReadTUint32L (const RMessage2& aMessage,

	TMceItcArguments aItcArgIndex) const

	{

    TPckgBuf<TUint32> mceDataPckg;

    aMessage.ReadL (aItcArgIndex, mceDataPckg);

    return mceDataPckg();

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ReadIntL

// -----------------------------------------------------------------------------

//

TInt CMceCsServerITC::ReadIntL(const RMessage2& aMessage, 

	TMceItcArguments aItcArgIndex) const

	{

    TInt integer = 0;

    switch (static_cast<TInt>(aItcArgIndex))

		{

        case KInt0: 

        	integer = aMessage.Int0();

        	break;

        case KInt1: 

        	integer = aMessage.Int1();

        	break;

        case KInt2: 

        	integer = aMessage.Int2();

        	break;

        case KInt3: 

        	integer = aMessage.Int3();

        	break;

        default: 

        	User::Leave(KErrNotFound);

		}

    return integer; 

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ReadLC

// -----------------------------------------------------------------------------

//

HBufC8* CMceCsServerITC::ReadLC (const RMessage2&  aMessage,

                                 TMceItcArguments aItcArgIndex) const

	{

    TInt length = aMessage.GetDesLength (aItcArgIndex);

    if (length < 0)

        {

        User::Leave (KErrBadDescriptor);

        }

    HBufC8* buf = HBufC8::NewLC (length);

	if (length > 0)

		{

		TPtr8 bufPtr(buf->Des());

		aMessage.ReadL (aItcArgIndex, bufPtr);

		}

    return buf;

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::Function

// -----------------------------------------------------------------------------

//

TInt CMceCsServerITC::Function (const RMessage2& aMessage) const

	{

    return aMessage.Function();

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::Complete

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::Complete (const RMessage2& aMessage,

                                TInt aCompletionCode) const

	{

    aMessage.Complete (aCompletionCode);

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::PanicClient

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::PanicClient(const RMessage2& aMessage, TInt aPanic) const

	{

    RThread client;

    aMessage.Client(client);

    client.Panic(KMceServerPanic, aPanic);

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ITCArgPtr

// -----------------------------------------------------------------------------

//

const TAny* CMceCsServerITC::ITCArgPtr (TMceItcArguments aItcArgIndex,

                                        const RMessage2&  aMessage) const

	{

    const TAny* ptr;

    switch (static_cast<TInt>(aItcArgIndex))

		{

        case KInt0: ptr = aMessage.Ptr0(); break;

        case KInt1: ptr = aMessage.Ptr1(); break;

        case KInt2: ptr = aMessage.Ptr2(); break;

        case KInt3: ptr = aMessage.Ptr3(); break;

        default: ptr = 0; break;

		}

    return ptr; 

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ITCArgInt

// -----------------------------------------------------------------------------

//

TInt CMceCsServerITC::ITCArgInt (TMceItcArguments aItcArgIndex,

                                 const RMessage2&  aMessage) const

	{

    TInt integer;

    switch (static_cast<TInt>(aItcArgIndex))

		{

        case KInt0: integer = aMessage.Int0(); break;

        case KInt1: integer = aMessage.Int1(); break;

        case KInt2: integer = aMessage.Int2(); break;

        case KInt3: integer = aMessage.Int3(); break;

        default: integer = KErrArgument; break;

		}

    return integer; 

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::WriteL

// -----------------------------------------------------------------------------

//

void CMceCsServerITC::WriteL (TMceItcArguments aItcArgIndex,

							  const RMessage2&  aMessage,

							  const TDesC8&    aDes) const

	{

    TInt length = aMessage.GetDesMaxLength(aItcArgIndex);

    if (length < 0)

        {

        User::Leave (KErrArgument);

        }

    if (length < aDes.Length())

        {

        User::Leave (KErrOverflow);

        }

    aMessage.WriteL (aItcArgIndex, aDes);

	}

// -----------------------------------------------------------------------------

// CMceCsServerITC::ReadL

// -----------------------------------------------------------------------------

//

HBufC8* CMceCsServerITC::ReadL (const RMessage2&  aMessage,

                                TMceItcArguments aItcArgIndex) const

	{

	HBufC8* buf = ReadLC(aMessage,aItcArgIndex);

    CleanupStack::Pop(buf);

	return buf;

	}