/*

* Copyright (c) 2009-2010 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:

* Client side IPC handling for Connection Method Manager server.

*

*/

#include <cmmanagerdef.h>

#include "cmmserverdefs.h"

#include "cmmanagerapi.h"

#include "cmdestinationwrapper.h"

#include "cmconnectionmethodwrapper.h"

#include "cmmclistatic.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmanagerapiTraces.h"

#endif

RCmManagerApi::RCmManagerApi() : RSessionBase()

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_RCMMANAGERAPI_ENTRY );

    iConnected = EFalse;

    iSmallBufsForDestinations = ETrue;

    iSmallBufsForConnMethods = ETrue;

    OstTraceFunctionExit0( RCMMANAGERAPI_RCMMANAGERAPI_EXIT );

    }

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

// RCmManagerApi::Connect()

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

//

TInt RCmManagerApi::Connect()

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_CONNECT_ENTRY );

    if ( !iConnected )

        {

        TInt retry = 2;

        for (;;)

            {

            TInt err = CreateSession( KCmmServer, TVersion( 0, 0, 0 ), KCmmDefaultMessageSlots );

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

                {

                if ( !err )

                    {

                    iConnected = ETrue;

                    }

                OstTraceFunctionExit0( RCMMANAGERAPI_CONNECT_EXIT );

                return err;

                }

            // KErrNotFound and KErrServerTerminated will go through.

            if ( --retry <= 0 )

                {

                OstTraceFunctionExit0( DUP1_RCMMANAGERAPI_CONNECT_EXIT );

                return err;

                }

            err = TCmManagerLauncher::LaunchServer(

                    KCmmServer,

                    KCmmServerFile,

                    KCmmUid3,

                    KCmmServerInitHeapSize,

                    KCmmServerMaxHeapSize,

                    KCmmServerStackSize );

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

                {

                // Failed to launch server, and it wasn't already running.

                OstTraceFunctionExit0( DUP2_RCMMANAGERAPI_CONNECT_EXIT );

                return err;

                }

            }

        }

    OstTraceFunctionExit0( DUP3_RCMMANAGERAPI_CONNECT_EXIT );

    return KErrNone;

    }

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

// RCmManagerApi::Close()

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

//

void RCmManagerApi::Close()

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_CLOSE_ENTRY );

    if ( iConnected )

        {

        // Close all subsessions first.

        //

        // Don't call subsession destructors (wrappers), since they will try to

        // remove themselves from these pointer arrays. Here we can just close

        // the arrays at the end.

        for ( TInt i = 0; i < iConnMethods.Count(); i++ )

            {

            iConnMethods[i]->CloseSession();

            }

        iConnMethods.Close();

        for ( TInt i = 0; i < iDestinations.Count(); i++ )

            {

            iDestinations[i]->CloseSession();

            }

        iDestinations.Close();

        RSessionBase::Close();

        iConnected = EFalse;

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_CLOSE_EXIT );

    }

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

// RCmManagerApi::StoreDestinationWrapper()

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

//

TInt RCmManagerApi::StoreDestinationWrapper(

        CCmDestinationWrapper* aDestinationWrapper )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_STOREDESTINATIONWRAPPER_ENTRY );

    TInt err = iDestinations.InsertInAddressOrder( aDestinationWrapper );

    OstTraceFunctionExit0( RCMMANAGERAPI_STOREDESTINATIONWRAPPER_EXIT );

    return err;

    }

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

// RCmManagerApi::RemoveDestinationWrapper()

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

//

TInt RCmManagerApi::RemoveDestinationWrapper(

        CCmDestinationWrapper* aDestinationWrapper )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_REMOVEDESTINATIONPOINTER_ENTRY );

    TInt index = iDestinations.FindInAddressOrder( aDestinationWrapper );

    if ( index >= 0 )

        {

        iDestinations.Remove( index );

        index = KErrNone;

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_REMOVEDESTINATIONPOINTER_EXIT );

    return index;

    }

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

// RCmManagerApi::GetDestinationWrapperL()

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

//

CCmDestinationWrapper* RCmManagerApi::GetDestinationWrapperL( const TInt& aHandle )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETDESTINATIONWRAPPER_ENTRY );

    CCmDestinationWrapper* result( NULL );

    if ( aHandle )

        {

        for ( TInt i = 0; i < iDestinations.Count(); i++ )

            {

            if ( iDestinations[i]->GetHandle() == aHandle )

                {

                result = iDestinations[i];

                break;

                }

            }

        }

    if ( !result )

        {

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_GETDESTINATIONWRAPPER_EXIT );

    return result;

    }

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

// RCmManagerApi::StoreConnMethodWrapper()

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

//

TInt RCmManagerApi::StoreConnMethodWrapper(

        CCmConnectionMethodWrapper* aConnMethodWrapper )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_STORECONNMETHODWRAPPER_ENTRY );

    TInt err = iConnMethods.InsertInAddressOrder( aConnMethodWrapper );

    OstTraceFunctionExit0( RCMMANAGERAPI_STORECONNMETHODWRAPPER_EXIT );

    return err;

    }

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

// RCmManagerApi::RemoveConnMethodWrapper()

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

//

TInt RCmManagerApi::RemoveConnMethodWrapper(

        CCmConnectionMethodWrapper* aConnMethodWrapper )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_REMOVECONNMETHODPOINTER_ENTRY );

    TInt index = iConnMethods.FindInAddressOrder( aConnMethodWrapper );

    if ( index >= 0 )

        {

        iConnMethods.Remove( index );

        index = KErrNone;

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_REMOVECONNMETHODPOINTER_EXIT );

    return index;

    }

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

// RCmManagerApi::GetConnMethodWrapperL()

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

//

CCmConnectionMethodWrapper* RCmManagerApi::GetConnMethodWrapperL( const TInt& aHandle )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNMETHODWRAPPER_ENTRY );

    CCmConnectionMethodWrapper* result( NULL );

    if ( aHandle )

        {

        for ( TInt i = 0; i < iConnMethods.Count(); i++ )

            {

            if ( iConnMethods[i]->GetHandle() == aHandle )

                {

                result = iConnMethods[i];

                break;

                }

            }

        }

    if ( !result )

        {

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNMETHODWRAPPER_EXIT );

    return result;

    }

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

// RCmManagerApi::GetBearerInfoInt()

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

//

TInt RCmManagerApi::GetBearerInfoInt(

        const TUint32 aBearerType,

        const TUint32 aAttribute,

        TUint32& aValue )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETBEARERINFOINT_ENTRY );

    TPckg<TUint32> pckg( aValue );

    TIpcArgs args( aBearerType, aAttribute, &pckg );

    TInt err = SendReceive( ECmmGetBearerInfoInt, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETBEARERINFOINT_EXIT );

    return err;

    }

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

// RCmManagerApi::GetBearerInfoBool()

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

//

TInt RCmManagerApi::GetBearerInfoBool(

        const TUint32 aBearerType,

        const TUint32 aAttribute,

        TBool& aValue )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETBEARERINFOBOOL_ENTRY );

    TPckg<TBool> pckg( aValue );

    TIpcArgs args( aBearerType, aAttribute, &pckg );

    TInt err = SendReceive( ECmmGetBearerInfoBool, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETBEARERINFOBOOL_EXIT );

    return err;

    }

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

// RCmManagerApi::GetBearerInfoString()

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

//

TInt RCmManagerApi::GetBearerInfoString(

        const TUint32 aBearerType,

        const TUint32 aAttribute,

        HBufC* aBuffer )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETBEARERINFOSTRING_ENTRY );

    TPtr descriptor( aBuffer->Des() );

    TIpcArgs args( aBearerType, aAttribute, &descriptor );

    TInt err = SendReceive( ECmmGetBearerInfoString, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETBEARERINFOSTRING_EXIT );

    return err;

    }

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

// RCmManagerApi::GetBearerInfoString8()

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

//

TInt RCmManagerApi::GetBearerInfoString8(

        const TUint32 aBearerType,

        const TUint32 aAttribute,

        HBufC8* aBuffer8 )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETBEARERINFOSTRING8_ENTRY );

    TPtr8 descriptor( aBuffer8->Des() );

    TIpcArgs args( aBearerType, aAttribute, &descriptor );

    TInt err = SendReceive( ECmmGetBearerInfoString8, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETBEARERINFOSTRING8_EXIT );

    return err;

    }

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

// RCmManagerApi::GetConnectionMethodInfoInt()

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

//

TInt RCmManagerApi::GetConnectionMethodInfoInt(

        const TUint32 aIapId,

        const TUint32 aAttribute,

        TUint32& aValue )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOINT_ENTRY );

    TPckg<TUint32> pckg( aValue );

    TIpcArgs args( aIapId, aAttribute, &pckg );

    TInt err = SendReceive( ECmmGetConnMethodInfoInt, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOINT_EXIT );

    return err;

    }

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

// RCmManagerApi::GetConnectionMethodInfoBool()

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

//

TInt RCmManagerApi::GetConnectionMethodInfoBool(

        const TUint32 aIapId,

        const TUint32 aAttribute,

        TBool& aValue )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOBOOL_ENTRY );

    TPckg<TUint32> pckg( aValue );

    TIpcArgs args( aIapId, aAttribute, &pckg );

    TInt err = SendReceive( ECmmGetConnMethodInfoBool, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOBOOL_EXIT );

    return err;

    }

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

// RCmManagerApi::GetConnectionMethodInfoString()

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

//

TInt RCmManagerApi::GetConnectionMethodInfoString(

        const TUint32 aIapId,

        const TUint32 aAttribute,

        HBufC* aBuffer )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOSTRING_ENTRY );

    TPtr descriptor( aBuffer->Des() );

    TIpcArgs args( aIapId, aAttribute, &descriptor );

    TInt err = SendReceive( ECmmGetConnMethodInfoString, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOSTRING_EXIT );

    return err;

    }

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

// RCmManagerApi::GetConnectionMethodInfoString8()

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

//

TInt RCmManagerApi::GetConnectionMethodInfoString8(

        const TUint32 aIapId,

        const TUint32 aAttribute,

        HBufC8* aBuffer8 )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOSTRING8_ENTRY );

    TPtr8 descriptor( aBuffer8->Des() );

    TIpcArgs args( aIapId, aAttribute, &descriptor );

    TInt err = SendReceive( ECmmGetConnMethodInfoString8, args );

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNECTIONMETHODINFOSTRING8_EXIT );

    return err;

    }

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

// RCmManagerApi::GetConnMethodsL(

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

//

void RCmManagerApi::GetConnMethodsL(

        const TCmmIpcStructGetConnMethods& aParameters,

        RArray<TUint32>& aCmArray )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETCONNMETHODSL_ENTRY );

    TInt err( KErrNone );

    TInt count( KMaxTInt );

    TPckg<TInt> countPckg( count );

    TPckgBuf<TCmmIpcStructGetConnMethods> parametersPckg( aParameters );

    HBufC8* smallBuf( NULL );

    HBufC8* bigBuf( NULL );

    if ( iSmallBufsForConnMethods )

        {

        smallBuf = HBufC8::NewLC( KCmmConnMethodAmountNormal );

        TPtr8 smallBufPtr( smallBuf->Des() );

        TIpcArgs args( &parametersPckg, &countPckg, &smallBufPtr );

        err = SendReceive( ECmmGetConnMethodArray, args );

        User::LeaveIfError( err );

        }

    if ( countPckg() <= KCmmConnMethodAmountNormal )

        {

        aCmArray.Reset();

        aCmArray.ReserveL( countPckg() );

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

            {

            aCmArray.AppendL( (TUint32)(*smallBuf)[i] );

            }

        }

    else if ( countPckg() == KMaxTInt )

        {

        // All connection methods didn't fit into small array, ask again with big array.

        iSmallBufsForConnMethods = EFalse; // Switch small buffer mode off.

        if ( smallBuf )

            {

            CleanupStack::PopAndDestroy( smallBuf );

            smallBuf = NULL;

            }

        bigBuf = HBufC8::NewLC( KCmmConnMethodAmountMax );

        TPtr8 bigBufPtr( bigBuf->Des() );

        TIpcArgs args( &parametersPckg, &countPckg, &bigBufPtr );

        err = SendReceive( ECmmGetConnMethodArray, args );

        User::LeaveIfError( err );

        if ( countPckg() <= KCmmConnMethodAmountMax )

            {

            // Don't switch back to small buffer mode if client was only asking

            // for legacy connection methods (likely a small list).

            if ( countPckg() < KCmmConnMethodAmountNormal && aParameters.iLegacyOnly == EFalse )

                {

                iSmallBufsForConnMethods = ETrue; // Switch small buffer mode back on.

                }

            aCmArray.Reset();

            aCmArray.ReserveL( countPckg() );

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

                {

                aCmArray.AppendL( (TUint32)(*smallBuf)[i] );

                }

            }

        else

            {

            User::Leave( KErrUnknown );

            }

        CleanupStack::PopAndDestroy( bigBuf );

        }

    else

        {

        User::Leave( KErrUnknown );

        }

    if ( smallBuf )

        {

        CleanupStack::PopAndDestroy( smallBuf );

        }

    OstTraceFunctionExit0( RCMMANAGERAPI_GETCONNMETHODSL_EXIT );

    }

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

// RCmManagerApi::GetAllDestinationsL()

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

//

void RCmManagerApi::GetAllDestinationsL( RArray<TUint32>& aDestArray )

    {

    OstTraceFunctionEntry0( RCMMANAGERAPI_GETALLDESTINATIONSL_ENTRY );

    TInt err( KErrNone );

    TInt count( KMaxTInt );

    TPckg<TInt> countPckg( count );

    HBufC16* smallBuf( NULL );

    HBufC16* bigBuf( NULL );

    if ( iSmallBufsForDestinations )

        {

        smallBuf = HBufC16::NewLC( KCmmDestAmountNormal );

        TPtr16 smallBufPtr( smallBuf->Des() );

        TIpcArgs args( &countPckg, &smallBufPtr );

        err = SendReceive( ECmmGetAllDestinations, args );

        User::LeaveIfError( err );

        }

    if ( countPckg() <= KCmmDestAmountNormal )

        {

        aDestArray.Reset();

        aDestArray.ReserveL( countPckg() );

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

            {