/*

* Copyright (c) 2006-2008 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:  Sensor server message wrapper

*

*/

#include "sensrvdefines.h"

#include "sensrvtrace.h"

#include "sensrvmessage.h"

#include "sensrvsession.h"

#include "sensrvclientserver.h"

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

// Two-phased constructor for external message.

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

//

CSensrvMessage* CSensrvMessage::NewL()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::NewL()" ) ) );

    CSensrvMessage* self = new( ELeave ) CSensrvMessage();

    // No ConstructL as nothing to do there

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::NewL - return 0x%x" ), self ) );

    return self;

    }

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

// CSensrvMessage::CSensrvMessage

// C++ constructor for external message

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

//

CSensrvMessage::CSensrvMessage()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::CSensrvMessage()" ) ) );

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::CSensrvMessage - return" )) );

    }

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

// Destructor, completes message with error if not yet done so

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

//

CSensrvMessage::~CSensrvMessage()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::~CSensrvMessage()" ) ) );

    // if message is not yet completed, complete with error. 

    // This should never happen if everything works properly

    if ( iMessage.Handle() )

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvMessage::~CSensrvMessage() - ERROR: External message not completed before destruction."  ) ) );

        iMessage.Complete(KErrGeneral);

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::~CSensrvMessage - return" ) ) );

    }

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

// Initializes the message

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

//

void CSensrvMessage::Initialize(const RMessage2& aMessage)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::Initialize()" ) ) );

    if (iMessage.Handle())

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvMessage::Initialize - ERROR: Previous message not completed, canceling it" ) ) );

        iMessage.Complete(KErrCancel);

        }

    iMessage = aMessage;

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::Initialize - return") ) );

    }

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

// Completes the message

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

//

void CSensrvMessage::Complete(TInt aReason)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::Complete(%d)" ), aReason ) );

    iMessage.Complete(aReason);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::Complete - return" )) );

    }

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

// Returns the session handling this message

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

//

CSensrvSession* CSensrvMessage::Session()

    {

    CSensrvSession* session = NULL;

    session = static_cast<CSensrvSession*>(iMessage.Session());

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::Session - return 0x%x" ), session ) );

    return session;

    }

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

// Writes data to message

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

//

TInt CSensrvMessage::Write(TInt aParam, const TDesC8& aDes, TInt aOffset)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::WriteL(aParam: %d, <descriptor>, aOffset: %d)" ), aParam, aOffset ) );

#ifdef COMPONENT_TRACE_DEBUG

    TInt len = aDes.Length();

       const TUint8* currentByte(aDes.Ptr());

    HBufC* str = HBufC::New(len*6 + 20);

    if (str)

        {

        str->Des().Append(_L("### <descriptor>: 0x"));

        for (TInt j=0;j<len;j++)

            {

            str->Des().AppendNumUC(*currentByte, EHex);

            if ( j < (len-1) )

                {

                if ( (j%8) == 7 )

                    {

                    COMPONENT_TRACE((*str));

                    str->Des().Delete(0, 1000);

                    str->Des().Append(_L("###             : 0x"));

                    }

                else

                    {

                    str->Des().Append(_L(", 0x"));

                    }

                }        

            currentByte++;    

            }

        COMPONENT_TRACE((*str));

        delete str;

        str = NULL;

        }

#endif    

    TInt err(KErrNone);

    err = iMessage.Write(aParam, aDes, aOffset);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::WriteL - return %d" ), err ) );

    return err;

    }

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

// Gets maximum lenght of descriptor in specified index

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

//

TInt CSensrvMessage::GetDesMaxLength(TInt aParam) const

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetDesMaxLengthL(%d)" ), aParam ) );

    TInt length(0);

    length = iMessage.GetDesMaxLength(aParam);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetDesMaxLengthL - return: %d" ), length) );

    return length;

    }    

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

// Gets lenght of descriptor in specified index

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

//

TInt CSensrvMessage::GetDesLength(TInt aParam) const

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetDesLength(%d)" ), aParam ) );

    TInt lenght(0);

    lenght = iMessage.GetDesLength(aParam);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetDesLength - return: %d" ), lenght) );

    return lenght;

    }    

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

// Gets maximum lenght of descriptor in specified index

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

//

TSecureId CSensrvMessage::SecureId() const    

    {

    TUint32 sid(0);

    sid = iMessage.SecureId();

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::SecureId - return 0x%x" ), sid ) );    

    return TSecureId(sid);    

    }

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

// Read data from wrapped message. 

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

//     

TInt CSensrvMessage::Read( const TInt aParam, TDes8 &aDes ) const

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::ReadL(aParam: %d, <descriptor>)" ), aParam ) );

    TInt err(KErrNone);

    err = iMessage.Read( aParam, aDes );

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::ReadL - return %d" ), err) );    

    return err;

    }

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

// Read integer data from wrapped message. 

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

//     

void CSensrvMessage::ReadInt( const TInt aParam, TInt &aInt ) const

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::ReadInt(aParam: %d, <target>)" ), aParam ) );

    switch(aParam)

        {

        case 0:

            aInt = iMessage.Int0();

            break;

        case 1:

            aInt = iMessage.Int1();

            break;

        case 2:

            aInt = iMessage.Int2();

            break;

        case 3:

            aInt = iMessage.Int3();

            break;

        default:

            User::Panic(KSensrvPanicCategory, ESensrvPanicOutOfBounds);

            break;               

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::ReadInt - return, aInt: %d" ), aInt) );    

    }

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

// Gets channel id from message. 

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

//

TInt CSensrvMessage::GetChannelId(TSensrvChannelId& aChannelId) const    

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetChannelId(<retval>)" ) ) );

    TInt err(KErrNone);

    // Make sure message type supports channel id.

    TInt function = Function();

    if (   function == ESensrvSrvReqOpenChannel 

        || function == ESensrvSrvReqCloseChannel 

        || function == ESensrvSrvReqStartListening 

        || function == ESensrvSrvReqStopListening 

        || function == ESensrvSrvReqAsyncChannelData

        || function == ESensrvSrvReqGetProperty

        || function == ESensrvSrvReqSetProperty

        || function == ESensrvSrvReqAsyncPropertyData

        || function == ESensrvSrvReqStopPropertyListening

        || function == ESensrvSrvReqGetAllProperties 

        || function == ESensrvSrvReqAddConditionSet

        || function == ESensrvSrvReqRemoveConditionSet

        || function == ESensrvSrvReqStartConditionListening

        || function == ESensrvSrvReqStopConditionListening

        || function == ESensrvSrvReqAsyncConditionMet

       )

        {

        // Read required channel id from message

        // Channel id is always on message parameter KSensrvChannelIdSlot, i.e. slot zero.

        aChannelId = iMessage.Int0();

        }

    else

        {

        err = KErrNotSupported;

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetChannelId - return %d, channel id: %d" ), err, aChannelId) );

    return err;

    }

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

// Gets client security info from message. 

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

//

void CSensrvMessage::GetSecurityInfo(TSecurityInfo& aSecurityInfo) const    

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetSecurityInfo(<retval>)" ) ) );

    // Read required channel id from message

    aSecurityInfo.Set(iMessage);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvMessage::GetSecurityInfo - return" ) ) );

    }