/*

* Copyright (c) 2002-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:  Implementation for Connection Monitor Server API methods.

*

*/

#include <rconnmon.h>

#include "ConnMonDef.h"

#include "ConnMonCli.h"

#include "ConnMonServ.h"

#include "log.h"

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

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

// RConnectionMonitor::ConnectL

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

//

EXPORT_C TInt RConnectionMonitor::ConnectL()

    {

    //LOGENTRFN("RConnectionMonitor::ConnectL()")

    LOGIT1("Client [%d]: calling ConnectL()", this)

    if ( IsConnected() )

        {

        LOGIT1("Client [%d]: already connected", this)

        return KErrNone;

        }

    // Connect to server

    TInt errConnect( KErrNone );

    TInt errLaunch( KErrNone );

    for ( TInt tries = 0; tries < 2; tries++ )

        {

        // This initialization is needed if some application starts

        // ConnMon server just between CreateSession() and

        // LaunchFromClient() here.

        errLaunch = KErrNone;

        errConnect = CreateSession(

                KConnectionMonitorServerName,

                TVersion( 0, 0, 0 ),

                KNumMessageSlots );

        if ( errConnect )

            {

            if ( errConnect != KErrNotFound && errConnect != KErrServerTerminated )

                {

                break; // Problems other than server not here - propagate error

                }

            errLaunch = CConnMonScheduler::LaunchFromClient();

            // If server launched ok (KErrNone), try again to connect

            // If someone else got there first (KErrAlreadyExists), try again to connect

            if ( errLaunch != KErrNone && errLaunch != KErrAlreadyExists )

                {

                break; // Server not launched: don't cycle round again

                }

            }

        else

            {

            break;

            }

        }

    User::LeaveIfError( errConnect );

    User::LeaveIfError( errLaunch );

    // Initialize an array for holding the non-descriptor parameters that are

    // passed along asyncronous methods to the server. (Inter-thread reads/writes

    // are possible only on desc data.)

    if ( iPtrArray.Count() == 0 )

        {

        TPtr8 ptr( reinterpret_cast<TUint8*>( NULL ), 0 );

        for ( TInt i = 0; i < KNumPtrs; i++ )

            {

            User::LeaveIfError( iPtrArray.Append( ptr ) );

            }

        }

#ifdef _DEBUG

    TName processName = RProcess().Name();

    if ( processName.Length() < KMaxName )

        {

        LOGIT2("Client [%d]: process name [%s]", this, processName.PtrZ())

        }

#endif // _DEBUG

    //LOGEXITFN("RConnectionMonitor::ConnectL()")

    return KErrNone;

    }

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

// RConnectionMonitor::Close

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

//

EXPORT_C void RConnectionMonitor::Close()

    {

    //LOGENTRFN("RConnectionMonitor::Close()")

    // Destroy pointer array

    iPtrArray.Close();

    // Destroy notification handler

    delete iHandler;

    iHandler = NULL;

    // Destroy server session

    RSessionBase::Close();

    LOGIT1("Client [%d]: closed!", this)

    //LOGEXITFN("RConnectionMonitor::Close()")

    }

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

// RConnectionMonitor::GetConnectionCount

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

//

EXPORT_C void RConnectionMonitor::GetConnectionCount(

        TUint& aConnectionCount,

        TRequestStatus& aStatus )

    {

    LOGIT1("Client [%d]: GetConnectionCount()", this)

    TPtr8& pckg = NextPtr();

    pckg.Set(

            reinterpret_cast<TUint8*>( &aConnectionCount ),

            sizeof( aConnectionCount ),

            sizeof( aConnectionCount ) );

    TIpcArgs args( &pckg );

    SendReceive( EReqGetConnectionCount, args, aStatus );

    }

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

// RConnectionMonitor::GetConnectionInfo

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

//

EXPORT_C TInt RConnectionMonitor::GetConnectionInfo(

        const TUint aIndex,

        TUint& aConnectionId,

        TUint& aSubConnectionCount ) const

    {

    LOGIT2("Client [%d]: GetConnectionInfo(), index %d", this, aIndex)

    TPtr8 n( reinterpret_cast<TUint8*>( &aConnectionId ), sizeof( aConnectionId ) );

    TPtr8 m( reinterpret_cast<TUint8*>( &aSubConnectionCount ), sizeof( aSubConnectionCount ) );

    TIpcArgs args( aIndex, &n, &m );

    return( SendReceive( EReqGetConnectionInfo, args ) );

    }

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

// RConnectionMonitor::GetSubConnectionInfo

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

//

EXPORT_C TInt RConnectionMonitor::GetSubConnectionInfo(

        const TUint aConnectionId,

        const TUint aIndex,

        TUint& aSubConnectionId ) const

    {

    LOGIT3("Client [%d]: GetSubConnectionInfo(), conn.id %d, index %d", this, aConnectionId, aIndex)

    TPtr8 n( reinterpret_cast<TUint8*>( &aSubConnectionId ), sizeof( aSubConnectionId ) );

    TIpcArgs args( aConnectionId, aIndex, &n );

    return( SendReceive( EReqGetSubConnectionInfo, args ) );

    }

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

// RConnectionMonitor::GetIntAttribute

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

//

EXPORT_C void RConnectionMonitor::GetIntAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TInt& aValue,

        TRequestStatus& aStatus )

    {

    LOGIT4("Client [%d]: GetIntAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TPtr8& pckg = NextPtr();

    pckg.Set( reinterpret_cast<TUint8*>( &aValue ), sizeof( aValue ), sizeof( aValue ) );

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &pckg );

    SendReceive( EReqGetIntAttribute, args, aStatus );

    }

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

// RConnectionMonitor::GetUintAttribute

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

//

EXPORT_C void RConnectionMonitor::GetUintAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TUint& aValue,

        TRequestStatus& aStatus )

    {

    LOGIT4("Client [%d]: GetUintAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TPtr8& pckg = NextPtr();

    pckg.Set( reinterpret_cast<TUint8*>( &aValue ), sizeof( aValue ), sizeof( aValue ) );

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &pckg );

    SendReceive( EReqGetUintAttribute, args, aStatus );

    }

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

// RConnectionMonitor::GetBoolAttribute

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

//

EXPORT_C void RConnectionMonitor::GetBoolAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TBool& aValue,

        TRequestStatus& aStatus )

    {

    LOGIT4("Client [%d]: GetBoolAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TPtr8& pckg = NextPtr();

    pckg.Set( reinterpret_cast<TUint8*>( &aValue ), sizeof( aValue ), sizeof( aValue ) );

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &pckg );

    SendReceive( EReqGetBoolAttribute, args, aStatus );

    }

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

// RConnectionMonitor::GetStringAttribute

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

//

EXPORT_C void RConnectionMonitor::GetStringAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TDes& aValue,

        TRequestStatus& aStatus ) const

    {

    LOGIT4("Client [%d]: GetStringAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &aValue );

    SendReceive( EReqGetStringAttribute, args, aStatus );

    }

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

// RConnectionMonitor::GetPckgAttribute

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

//

EXPORT_C void RConnectionMonitor::GetPckgAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TDes8& aValue,

        TRequestStatus& aStatus ) const

    {

    LOGIT4("Client [%d]: 8GetPckgAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &aValue );

    SendReceive( EReqGetPckgAttribute, args, aStatus );

    }

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

// RConnectionMonitor::GetPckgAttribute

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

//

EXPORT_C void RConnectionMonitor::GetPckgAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        TDes16& aValue,

        TRequestStatus& aStatus ) const

    {

    LOGIT4("Client [%d]: 16GetPckgAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &aValue );

    SendReceive( EReqGetPckgAttribute, args, aStatus );

    }

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

// RConnectionMonitor::SetIntAttribute

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

//

EXPORT_C TInt RConnectionMonitor::SetIntAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        const TInt aValue ) const

    {

    LOGIT5("Client [%d]: SetIntAttribute(), conn.id %d, sub.conn.id %d, attribute %d, value %d",

            this, aConnectionId, aSubConnectionId, aAttribute, aValue)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, aValue );

    return( SendReceive( EReqSetIntAttribute, args ) );

    }

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

// RConnectionMonitor::SetUintAttribute

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

//

EXPORT_C TInt RConnectionMonitor::SetUintAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        const TUint aValue ) const

    {

    LOGIT5("Client [%d]: SetUintAttribute(), conn.id %d, sub.conn.id %d, attribute %d, value %d",

            this, aConnectionId, aSubConnectionId, aAttribute, aValue)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, aValue );

    return( SendReceive( EReqSetUintAttribute, args ) );

    }

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

// RConnectionMonitor::SetBoolAttribute

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

//

EXPORT_C TInt RConnectionMonitor::SetBoolAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        const TBool aValue ) const

    {

    LOGIT5("Client [%d]: SetBoolAttribute(), conn.id %d, sub.conn.id %d, attribute %d, value %d",

            this, aConnectionId, aSubConnectionId, aAttribute, aValue)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, aValue );

    return( SendReceive( EReqSetBoolAttribute, args ) );

    }

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

// RConnectionMonitor::SetStringAttribute

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

//

EXPORT_C TInt RConnectionMonitor::SetStringAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        const TDes& aValue ) const

    {

    LOGIT4("Client [%d]: SetStringAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &aValue );

    return( SendReceive( EReqSetStringAttribute, args ) );

    }

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

// RConnectionMonitor::SetPckgAttribute

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

//

EXPORT_C TInt RConnectionMonitor::SetPckgAttribute(

        const TUint aConnectionId,

        const TUint aSubConnectionId,

        const TUint aAttribute,

        const TDes8& aValue ) const

    {

    LOGIT4("Client [%d]: SetPckgAttribute(), conn.id %d, sub.conn.id %d, attribute %d",

            this, aConnectionId, aSubConnectionId, aAttribute)

    TIpcArgs args( aConnectionId, aSubConnectionId, aAttribute, &aValue );

    return( SendReceive( EReqSetPckgAttribute, args ) );

    }

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

// RConnectionMonitor::CancelAsyncRequest

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

//

EXPORT_C void RConnectionMonitor::CancelAsyncRequest( TInt aReqToCancel )

    {

    LOGIT2("Client [%d]: CancelAsyncRequest(), request to cancel: %d", this, aReqToCancel)

    TIpcArgs args( aReqToCancel );

    SendReceive( EReqCancelAsyncRequest, args );

    }

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

// RConnectionMonitor::NotifyEventL

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

//

EXPORT_C TInt RConnectionMonitor::NotifyEventL( MConnectionMonitorObserver& aObserver )

    {

    LOGIT1("Client [%d]: NotifyEventL()", this)

    if ( iHandler == 0)

        {

        // Create active object to receive events and add it to scheduler

        iHandler = new( ELeave ) CConnMonEventHandler( &aObserver, *this );

        iHandler->Construct();

        // Kick off receive handler active object to start listening and start a receive

        iHandler->ReceiveNotification();

        }

    else

        {

        // Continue paused event handler.

        iHandler->Continue( &aObserver );

        }

    return KErrNone;

    }

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

// RConnectionMonitor::CancelNotifications

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

//

EXPORT_C void RConnectionMonitor::CancelNotifications()

    {

    LOGIT1("Client [%d]: CancelNotifications()", this)

    if ( iHandler != 0 )

        {

        if ( iHandler->IsActive() )

            {

            // Cancel event receiver

            iHandler->Cancel();

            // Delete and remove from active scheduler

            //iHandler->Deque;

            delete iHandler;

            iHandler = NULL;

            }

        else

            {

            // Client has cancelled notifications from

            // EventL() method. -> can't delete the iHandler object.

            // CancelReceiveEvent() needs to be called to set

            // iListening flag of this session in the server to 'false'.

            CancelReceiveEvent();

            iHandler->Pause();

            }

        }

    }

// Private methods in conjunction with CConnMonEventHandler

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

// RConnectionMonitor::ReceiveEvent

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

//

void RConnectionMonitor::ReceiveEvent(

        TDes8& aBuffer,

        TDes8& aExtraBuf,

        TRequestStatus& aStatus )

    {

    //LOGIT1("Client [%d]: waiting for next event", this)

    TIpcArgs args( &aBuffer, &aExtraBuf );

    SendReceive( EReqReceiveEvent, args, aStatus );

    }

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

// RConnectionMonitor::CancelReceiveEvent

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

//

void RConnectionMonitor::CancelReceiveEvent()

    {

    LOGIT1("Client [%d]: CancelReceiveEvent()", this)

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

    }

// Private internal methods

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

// RConnectionMonitor::IsConnected

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

//

TBool RConnectionMonitor::IsConnected() const

    {

    if ( iPtrArray.Count() > 0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// RConnectionMonitor::NextPtr

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

//

TPtr8& RConnectionMonitor::NextPtr()

    {

    __ASSERT_ALWAYS( IsConnected(), Panic( EConnMonPanicClientNotConnected ) );

    if ( iIndex >= iPtrArray.Count() )

        {

        iIndex = 0;

        }