/*

* Copyright (c) 2004 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:  Connection Monitor Extension.

*

*/

#include "ConnMonExt.h"

#include "log.h"

// ============================ LOCAL FUNCTIONS ===============================

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

// Panic

// Panics the client in case of programming error.

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

//

void Panic( TInt aPanic )

    {

    _LIT( KPanicCategory, "ConnectionMonitor Extension API" );

    User::Panic( KPanicCategory, aPanic );

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CConnectionMonitorPlugin::CConnectionMonitorPlugin

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

//

EXPORT_C CConnectionMonitorPlugin::CConnectionMonitorPlugin()

    {

    iPluginAO = 0;

    }

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

// Destructor

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

//

EXPORT_C CConnectionMonitorPlugin::~CConnectionMonitorPlugin()

    {

    delete iPluginAO;

    }

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

// CConnectionMonitorPlugin::RegisterPlugin

// Starts plugin session and registers the plug-in.

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

//

EXPORT_C void CConnectionMonitorPlugin::RegisterPluginL( const TUint aConnectionId )

    {

    if ( iPluginAO == 0 )

        {

        // Create the receiver (active object)

        iPluginAO = new ( ELeave ) CPluginAO( iSession, *this );

        iPluginAO->ConstructL();

        // Connect to the Connection Monitor server

        iConnMonServer.ConnectL();

        // Open plug-in subsession to the Connection Monitor server

        TInt ret = iSession.Open( iConnMonServer, aConnectionId );

        if ( ret != KErrNone )

            {

            User::Leave( ret );

            }

        }

    iPluginAO->ReceiveQuery();

    LOG( Log::Printf( _L("Plugin [%d]: registered: Id:<%d>\n"), &iSession, aConnectionId ) );

    }

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

// CConnectionMonitorPlugin::CancelRegisterPlugin

// Cancels the plug-in's registration.

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

//

EXPORT_C void CConnectionMonitorPlugin::CancelRegisterPlugin()

    {

    if ( iPluginAO != 0 )

        {

        // Delete receiver

        delete iPluginAO;

        iPluginAO = 0;

        // Close plug-in subsession

        iSession.Close();

        // Disconnect from Connection Monitor server

        iConnMonServer.Close();

        LOG( Log::Printf( _L("Plugin [%d]: Cancelled registration.\n"), &iSession ) );

        }

    }

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

// CConnectionMonitorPlugin::RegisterAttribute

// Registers a new attribute to the Connection Monitor server.

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

//

EXPORT_C TInt CConnectionMonitorPlugin::RegisterAttribute( const TUint aAttribute ) const

    {

    LOG( Log::Printf( _L("Plugin [%d]: register attribute: Id:<%d>\n"), &iSession, aAttribute ) );

    return ( iSession.RegisterAttribute( aAttribute ) );

    }

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

// CConnectionMonitorPlugin::CancelRegisterAttribute

// Cancels the attribute registration from the Connection Monitor server.

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

//

EXPORT_C void CConnectionMonitorPlugin::CancelRegisterAttribute( const TUint aAttribute ) const

    {

    LOG( Log::Printf( _L("Plugin [%d]: Cancel attribute registration: Id:<%d>\n"), &iSession, aAttribute ) );

    iSession.CancelRegisterAttribute( aAttribute );

    }

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

// CConnectionMonitorPlugin::Event

// Sends an event to Connnection Monitor server.

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

//

EXPORT_C TInt CConnectionMonitorPlugin::Event( const TUint aEventId,

                                               const TAny* aData,

                                               const TUint aSize ) const

    {

    LOG( Log::Printf( _L("Plugin [%d]: Send event: EventId:<%d>\n"), &iSession, aEventId ) );

    return ( iSession.SendEvent( aEventId, aData, aSize ) );

    }

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

// CConnectionMonitorPlugin::Version

// Returns the client side version number.

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

//

EXPORT_C TVersion CConnectionMonitorPlugin::Version() const

    {

    LOG( Log::Printf( _L("Plugin [%d]: Get version.\n"), &iSession ) );

    return ( iSession.Version() );

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// RConnMonPlugin::Open

// Creates a new subsession with the Connection Monitor server.

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

//

TInt RConnMonPlugin::Open( RConnectionMonitor &aSession, const TUint aConnectionId  )

    {

    //p[0]= ( TAny* )aConnectionId ;

    TIpcArgs args( aConnectionId );

    return CreateSubSession( aSession, EReqPluginCreateSubSession, args );

    }

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

// RConnMonPlugin::Close

// Closes the subsession.

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

//

void RConnMonPlugin::Close()

    {

    RSubSessionBase::CloseSubSession( EReqPluginCloseSubSession );

    }

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

// RConnMonPlugin::Version

// Returns the client side version number.

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

//

TVersion RConnMonPlugin::Version() const

    {

    return( TVersion( KPluginMajorVersionNumber,

                      KPluginMinorVersionNumber,

                      KPluginBuildVersionNumber ) );

    }

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

// RConnMonPlugin::SendEvent

// Sends an event to the Connection Monitor server.

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

//

TInt RConnMonPlugin::SendEvent( const TUint aEventId,

                                const TAny* aData,

                                const TUint aSize ) const

    {

    if ( aSize > KConnMonMaxPluginDataSize )

        {

        return KErrTooBig;

        }

    TPtrC8 n( reinterpret_cast< const TUint8* >( aData ), aSize );

    //p[0]= ( TAny* )aEventId;

    //p[1]= ( TAny* )&n;

    TIpcArgs args( aEventId, &n );

    return SendReceive( EReqPluginEvent, args );

    }

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

// RConnMonPlugin::RegisterAttribute

// Registers an attribute to the Connection Monitor server.

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

//

TInt RConnMonPlugin::RegisterAttribute( const TUint aAttribute ) const

    {

    //p[0]= ( TAny* )aAttribute;

    TIpcArgs args( aAttribute );

    return SendReceive( EReqPluginRegisterAttribute, args );

    }

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

// RConnMonPlugin::CancelRegisterAttribute

// Cancels the attribute registration from the Connection Monitor server.

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

//

TInt RConnMonPlugin::CancelRegisterAttribute( const TUint aAttribute ) const

    {

    //p[0]= ( TAny* )aAttribute;

    TIpcArgs args( aAttribute );

    return SendReceive( EReqPluginCancelRegisterAttribute, args );

    }

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

// RConnMonPlugin::GetQuery

// Gets the next attribute request from the Connection Monitor server.

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

//

void RConnMonPlugin::GetQuery( TDes8& aBuffer, TRequestStatus& aStatus ) const

    {

    //p[ 0 ]= ( TAny* )&aBuffer;

    TIpcArgs args( &aBuffer );

    SendReceive( EReqPluginGetQuery, args, aStatus );

    }

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

// RConnMonPlugin::CancelGetQueyry

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

//

void RConnMonPlugin::CancelGetQuery() const

    {

    //SendReceive( EReqPluginCancelGetQuery, 0 );

    SendReceive( EReqPluginCancelGetQuery, TIpcArgs( TIpcArgs::ENothing ) );

    }

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

// RConnMonPlugin::SendAttribute

// Sends an attribute to the Connection Monitor server.

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

//

TInt RConnMonPlugin::SendAttribute( const TInt  aType,

                                    const TUint aAttribute,

                                    const TInt  aRet,

                                    const TAny* aValue,

                                    const TUint aSize ) const

    {

    if ( aSize > KConnMonMaxPluginDataSize )

        {

        return KErrTooBig;

        }

    //p[0]= ( TAny* )aAttribute;

    //p[1]= ( TAny* )aRet;

    if ( ( aType == EReqGetIntAttribute ) || ( aType == EReqGetUintAttribute ) ||

         ( aType == EReqGetBoolAttribute ) )

        {

        TPtrC8 n( reinterpret_cast< const TUint8* >( aValue ), aSize );

        //p[2]= ( TAny* )&n;

        TIpcArgs args( aAttribute, aRet, &n );

        return SendReceive( EReqPluginAttribute, args );

        }

    else

        {

        //p[2]= const_cast< TAny* >( aValue );

        TIpcArgs args( aAttribute, aRet, aValue );

        return SendReceive( EReqPluginAttribute, args );

        }

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CPluginAO::CPluginAO

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

//

CPluginAO::CPluginAO( RConnMonPlugin& aSession, CConnectionMonitorPlugin& aPlugin )

    :

    CActive( EPriorityStandard ),

    iSession( aSession ),

    iPlugin( aPlugin ),

    iBuf( NULL, 0, 0 )

    {

    }

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

// CPluginAO::ConstructL

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

//

void CPluginAO::ConstructL()

    {

    // Plug-in engine must have an active scheduler

    CActiveScheduler::Add( this );

    }

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

// Destructor

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

//

CPluginAO::~CPluginAO()

    {

    Cancel();

    }

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

// CPluginAO::ReceiveQuery

// Requests a new query from Connection Monitor server.

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

//

void CPluginAO::ReceiveQuery()

    {

    if ( IsActive() )

        {

        return;

        }

    else

        {

        // Must be passed as a descriptor

        iReqInfo.Reset();

        iBuf.Set( reinterpret_cast< TUint8* >( &iReqInfo ), sizeof( TReqInfo ), sizeof( TReqInfo ) );

        iSession.GetQuery( iBuf, iStatus );

        SetActive();

        }

    }

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

// CPluginAO::RunL

// Receives the a request from the Connection Monitor server and passes it to the

// plug-in module. Sends the result back to the server.

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

//

void CPluginAO::RunL()

    {

    if ( iStatus.Int() == KErrServerBusy )

        {

        // Message slot was reserved

        // Try again

        ReceiveQuery();

        }

    else if ( iStatus.Int() == KErrNone )

        {

        // A new request has arrived

        switch ( iReqInfo.iType )

            {

            case EReqGetIntAttribute:

                {

                TInt value( 0 );

                TInt ret = iPlugin.GetIntAttribute( iReqInfo.iAttribute, value );

                iSession.SendAttribute( EReqGetIntAttribute,

                                        iReqInfo.iAttribute,

                                        ret,

                                        &value,

                                        sizeof( TInt ) );

                break;

                }

            case EReqGetUintAttribute:

                {

                TUint value( 0 );

                TInt ret = iPlugin.GetUintAttribute( iReqInfo.iAttribute, value );

                iSession.SendAttribute( EReqGetUintAttribute,

                                        iReqInfo.iAttribute,

                                        ret,

                                        &value,

                                        sizeof( TUint ) );

                break;

                }

            case EReqGetBoolAttribute:

                {

                TBool value( EFalse );

                TInt ret = iPlugin.GetBoolAttribute( iReqInfo.iAttribute, value );

                iSession.SendAttribute( EReqGetBoolAttribute,

                                        iReqInfo.iAttribute,

                                        ret,

                                        &value,

                                        sizeof( TBool ) );

                break;

                }

            case EReqGetStringAttribute:

                {

                HBufC16* value = HBufC16::NewL( KConnMonMaxStringAttributeLength );

                TPtr16 auxPtr( const_cast< TUint16* >( value->Des().Ptr() ), KConnMonMaxStringAttributeLength );

                auxPtr.FillZ();

                TInt ret = iPlugin.GetStringAttribute( iReqInfo.iAttribute, auxPtr );

                iSession.SendAttribute( EReqGetStringAttribute,

                                        iReqInfo.iAttribute,

                                        ret,

                                        &auxPtr,

                                        auxPtr.MaxSize() );

                delete value;

                break;

                }

            case EReqGetPckgAttribute:

                {

                HBufC8* buf = HBufC8::New( KConnMonMaxPluginDataSize );

                TPtr8 initptr = buf->Des();

                TInt ret = iPlugin.GetPckgAttribute( iReqInfo.iAttribute, initptr );

                iSession.SendAttribute( EReqGetPckgAttribute,

                                        iReqInfo.iAttribute,

                                        ret,

                                        &initptr,

                                        KConnMonMaxPluginDataSize );

                delete buf;

                break;

                }

            case EReqSetIntAttribute:

                {

                iPlugin.SetIntAttribute( iReqInfo.iAttribute, iReqInfo.iData );

                break;

                }

            case EReqSetUintAttribute:

                {

                iPlugin.SetUintAttribute( iReqInfo.iAttribute, static_cast< TUint >( iReqInfo.iData ) );

                break;

                }

            case EReqSetBoolAttribute:

                {

                iPlugin.SetBoolAttribute( iReqInfo.iAttribute, static_cast< TBool >( iReqInfo.iData ) );

                break;

                }

            case EReqSetStringAttribute:

                {

                // Not supported

                break;

                }

            case EReqSetPckgAttribute:

                {

                // Not supported

                break;

                }

            default:

                break;

            }

        LOG( Log::Printf( _L("Plugin [%d]: served attribute query: Type:<%d>, Attribute:<%d> \n"),

                          &iSession,

                          iReqInfo.iType,

                          iReqInfo.iAttribute ) );

        // initiate the next receive

        ReceiveQuery();

        }

    else

        {

        // Log error

        LOG( Log::Printf( _L("Error in CPluginAO::RunL(): [%d].\n"), iStatus.Int() ) );

        }

    }

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

// CPluginAO::DoCancel

// Cancels the request from Connection Monitor server.

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

//

void CPluginAO::DoCancel()

    {

    if ( IsActive() )

        {

        iSession.CancelGetQuery();