/*

* Copyright (c) 2008-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:  Provider access to SNAPs

*

*/

#include <cmmanagerdef.h>

#include <cmpluginwlandef.h> // bearer type

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include <cmconnectionmethodext.h>

#include <cmpluginpacketdatadef.h>

#include "cchuilogger.h"

#include "cchuinotifconnectionhandler.h"

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

CCchUiNotifConnectionHandler::CCchUiNotifConnectionHandler()

    {

    }

void CCchUiNotifConnectionHandler::ConstructL()

    {

    iCmManagerExt.OpenL();

    }

CCchUiNotifConnectionHandler* CCchUiNotifConnectionHandler::NewL()

    {

    CCchUiNotifConnectionHandler* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

CCchUiNotifConnectionHandler* CCchUiNotifConnectionHandler::NewLC()

    {

    CCchUiNotifConnectionHandler* self =

        new (ELeave) CCchUiNotifConnectionHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CCchUiNotifConnectionHandler::~CCchUiNotifConnectionHandler()

    {

    iCmManagerExt.Close();

    }

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

// Gets GPRS access points from Internet SNAP

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

//

TUint32 CCchUiNotifConnectionHandler::GetGprsAccessPointsL( 

    CDesCArray& aIaps, RArray<TUint32>& aIapIds )

    {    

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::GetGprsAccessPointsL - IN" );

    TUint32 internetSnapId = KErrNone;

    RArray<TUint32> destIds = RArray<TUint32>( 1 );

    CleanupClosePushL( destIds );

    iCmManagerExt.AllDestinationsL( destIds );

    for ( TInt index = 0 ; index < destIds.Count() ; index++ )

        {

        RCmDestinationExt refDestination = 

            iCmManagerExt.DestinationL( destIds[index] );

        CleanupClosePushL( refDestination );    

        if ( refDestination.MetadataL( CMManager::ESnapMetadataInternet ) )

            {

            // Get all GPRS access point from this destination

            GetGprsAccessPointsFromSnapL( aIaps, aIapIds, refDestination );

            internetSnapId = refDestination.Id();

            }

        CleanupStack::PopAndDestroy( &refDestination );

        }

    CleanupStack::PopAndDestroy( &destIds );

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::GetGprsAccessPointsL - OUT" );

    return internetSnapId;

    } 

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

// Gets connection name.

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

//

void CCchUiNotifConnectionHandler::ConnectionNameL( 

    TUint aIapId, TDesC& aServiceName, RBuf& aIapName )

    {    

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::ConnectionNameL - IN" );

    if ( aIapId )

        {

        RCmConnectionMethodExt connMethod = 

        iCmManagerExt.ConnectionMethodL( aIapId );

        CleanupClosePushL( connMethod );

        HBufC* connName = connMethod.GetStringAttributeL( 

            CMManager::ECmName );

        CleanupStack::PushL( connName );

        aIapName.CreateL( connName->Des().Length() );

        aIapName.Copy( connName->Des() );

        CleanupStack::PopAndDestroy( connName );              

        CleanupStack::PopAndDestroy( &connMethod );

        }

    else

        {

        RArray<TUint32> destinationIds;

        CleanupClosePushL( destinationIds );

        iCmManagerExt.AllDestinationsL( destinationIds );

        for ( TInt i( 0 ) ; i < destinationIds.Count() ; i++ )

            {

            RCmDestinationExt dest = 

                iCmManagerExt.DestinationL( destinationIds[ i ] );

            CleanupClosePushL( dest );

            HBufC* destName = dest.NameLC();

            if ( destName->Des().Compare( aServiceName ) == 0  )

                {

                // Get highest priority connecton method from snap

                RCmConnectionMethodExt cm = dest.ConnectionMethodL( 0 );

                CleanupClosePushL( cm );

                HBufC* cmName = NULL;

                cmName = cm.GetStringAttributeL( CMManager::ECmName );

                if ( cmName )

                    {

                    CleanupStack::PushL( cmName );

                    aIapName.CreateL( cmName->Des().Length() );

                    aIapName.Copy( cmName->Des() );

                    CleanupStack::PopAndDestroy( cmName );

                    }

                CleanupStack::PopAndDestroy( &cm );

                }

            CleanupStack::PopAndDestroy( destName );

            CleanupStack::PopAndDestroy( &dest );

            }

        CleanupStack::PopAndDestroy( &destinationIds );

        }

    CCHUIDEBUG2( "ConnectionNameL - NAME=%S", &aIapName );

    CCHUIDEBUG( 

            "CCchUiNotifConnectionHandler::ConnectionNameL - OUT" );

    }

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

// Gets all but specified service´s destinations.

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

//

void CCchUiNotifConnectionHandler::GetDestinationsL( 

    TDesC& aServiceName, RArray<TUint32>& aDestinationIds )

    {  

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::GetDestinationsL - IN" );

    iCmManagerExt.AllDestinationsL( aDestinationIds );

    // Remove our services destination from destination ids.

    for ( TInt i( 0 ) ; i < aDestinationIds.Count() ; i++ )

        {

        RCmDestinationExt refDestination = 

        iCmManagerExt.DestinationL( aDestinationIds[ i ] );

        CleanupClosePushL( refDestination );

        HBufC* destName = refDestination.NameLC();

        if ( destName->Des().Compare( aServiceName ) == 0 )

            {

            CCHUIDEBUG( 

                "GetDestinationsL - remove current service´s destination" );

            aDestinationIds.Remove( i );

            aDestinationIds.Compress();

            }

        CleanupStack::PopAndDestroy( destName );      

        CleanupStack::PopAndDestroy( &refDestination );

        }

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::GetDestinationsL - OUT" );

    }

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

// CCchUiNotifConnectionHandler::GetDestinationL

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

//

void CCchUiNotifConnectionHandler::GetDestinationL( 

    TUint aIapId, TInt& aError, TUint32& aDestinationId )

    {

    CCHUIDEBUG2(

        "CCchUiNotifConnectionHandler::GetDestinationL - IN aIapID = %d", &aIapId );

    aError = KErrNotFound;

    RArray<TUint32> destinationIds;

    CleanupClosePushL( destinationIds );

    iCmManagerExt.AllDestinationsL( destinationIds );

    // Find our service destination from Iap ids.

    for ( TInt i( 0 ) ; i < destinationIds.Count() && KErrNone != aError; i++ )

        {

        RCmDestinationExt refDestination = 

            iCmManagerExt.DestinationL( destinationIds[ i ] );

        CleanupClosePushL( refDestination );

        HBufC* destName = refDestination.NameLC();

        RCmConnectionMethodExt connectionMethod;

        CleanupClosePushL( connectionMethod );

        TRAPD( error, connectionMethod =

            refDestination.ConnectionMethodByIDL( aIapId ) );

        if ( KErrNone == error )

            {

            CCHUIDEBUG( 

                "GetDestinationsL - IapID found from destination" );

            aDestinationId = destinationIds[ i ];

            aError = KErrNone;

            }

        CleanupStack::PopAndDestroy( &connectionMethod );

        CleanupStack::PopAndDestroy( destName );

        CleanupStack::PopAndDestroy( &refDestination );

        }

    CleanupStack::PopAndDestroy( &destinationIds );

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::GetDestinationL - OUT" );

    }

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

// Gets all access point ids from SNAP.

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

//

void CCchUiNotifConnectionHandler::GetAccessPointsFromSnapL( 

    RArray<TUint32>& aIapIds, TUint32 aDestinationId )

    {    

    CCHUIDEBUG( 

        "CCchUiNotifConnectionHandler::GetAccessPointsFromSnapL - IN" );

    CleanupClosePushL(aIapIds);

    RCmDestinationExt destination = 

                iCmManagerExt.DestinationL( aDestinationId );

    CleanupClosePushL( destination );

    for ( TInt index = 0 ; 

        index < destination.ConnectionMethodCount() ; index++ )

        {

        RCmConnectionMethodExt connMethod = 

            destination.ConnectionMethodL( index );

        CleanupClosePushL( connMethod );      

        TUint32 iapId = connMethod.GetIntAttributeL( CMManager::ECmIapId );

        aIapIds.AppendL( iapId );

        CleanupStack::PopAndDestroy( &connMethod );

        }

    CleanupStack::PopAndDestroy( &destination );

    CleanupStack::Pop();

    CCHUIDEBUG( 

        "CCchUiNotifConnectionHandler::GetAccessPointsFromSnapL - OUT" );

    }

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

// Gets GPRS access points from Internet SNAP

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

//

void CCchUiNotifConnectionHandler::GetGprsAccessPointsFromSnapL( 

    CDesCArray& aIaps, 

    RArray<TUint32>& aIapIds, 

    RCmDestinationExt& aDestination )

    {    

    CCHUIDEBUG( 

        "CCchUiNotifConnectionHandler::GetGprsAccessPointsFromSnapL - IN" );

    __ASSERT_ALWAYS( aDestination.ConnectionMethodCount(), 

        User::Leave( KErrNotFound ) );

    for ( TInt index = 0 ; 

        index < aDestination.ConnectionMethodCount() ; index++ )

        {

        RCmConnectionMethodExt connMethod = 

            aDestination.ConnectionMethodL( index );

        CleanupClosePushL( connMethod );

        if ( KUidPacketDataBearerType == connMethod.GetIntAttributeL( 

                CMManager::ECmBearerType ) )

            {

            HBufC* connName = 

                connMethod.GetStringAttributeL( CMManager::ECmName );

            CleanupStack::PushL( connName );

            CCHUIDEBUG( "GetGprsAccessPointsFromSnapL - iap name ok" );

            aIaps.AppendL( *connName );

            CleanupStack::PopAndDestroy( connName );    

            TUint32 iapId = connMethod.GetIntAttributeL( CMManager::ECmIapId );

            aIapIds.AppendL( iapId );

            CCHUIDEBUG2( "GetGprsAccessPointsFromSnapL - iap id: %d", iapId );

            }

        CleanupStack::PopAndDestroy( &connMethod );

        }

    CCHUIDEBUG( 

        "CCchUiNotifConnectionHandler::GetGprsAccessPointsFromSnapL - OUT" );

    }

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

// CCchUiNotifConnectionHandler::GetGprsAccessPointsSetToServiceSnapL

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

//

TInt CCchUiNotifConnectionHandler::GetGprsAccessPointsSetToServiceSnapL(

    CDesCArray& aIaps, RArray<TUint32>& aIapIds, TUint aIapId )

    {

    CCHUIDEBUG2( 

        "CCchUiNotifConnectionHandler::GetGprsAccessPointsSetToServiceSnapL - IN aIapId = %d", aIapId );

    TUint32 destinationId = 0;

    TInt error;

    GetDestinationL( aIapId, error, destinationId );

    if ( KErrNone == error )

        {

        CCHUIDEBUG2( 

            "GetGprsAccessPointsSetToServiceSnapL - destinationId = %d", destinationId );

        RCmDestinationExt refDestination;

        CleanupClosePushL( refDestination );

        TRAPD( error,

            refDestination = iCmManagerExt.DestinationL( destinationId ) );

        CCHUIDEBUG2(

            "GetGprsAccessPointsSetToServiceSnapL -Destination error %d", error );

        if ( KErrNone == error )

            {

            GetGprsAccessPointsFromSnapL( aIaps, aIapIds, refDestination );

            }

        CleanupStack::PopAndDestroy( &refDestination );

        }

    CCHUIDEBUG2(

        "CCchUiNotifConnectionHandler::GetGprsAccessPointsSetToServiceSnapL -return %d", error );

    return error;

    }

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

// CCchUiNotifConnectionHandler::IsConnectionMethodSimilarL

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

//

TBool CCchUiNotifConnectionHandler::IsConnectionMethodSimilarL(

    TUint32 aIapId, TUint32 aIapIdToCompare )

    {

    CCHUIDEBUG( "CCchUiNotifConnectionHandler::IsConnectionMethodSimilarL - IN" );

    TBool returnVal = EFalse;

    TUint32 bearerType = iCmManagerExt.GetConnectionMethodInfoIntL(

        aIapId, CMManager::ECmBearerType );

    if ( bearerType == iCmManagerExt.GetConnectionMethodInfoIntL(

        aIapIdToCompare, CMManager::ECmBearerType ) )

        {

        HBufC* buffer = NULL;

        HBufC* bufferToCompare = NULL;

        switch( bearerType )

            {

            case KUidWlanBearerType:

                CCHUIDEBUG( "IsConnectionMethodSimilarL - KUidWlanBearerType" );

                buffer = iCmManagerExt.GetConnectionMethodInfoStringL(

                    aIapId, CMManager::EWlanSSID );

                CCHUIDEBUG( "GetConnectionMethodInfoStringL - aIapId EWlanSSID OUT" );

                CleanupStack::PushL( buffer );

                bufferToCompare = iCmManagerExt.GetConnectionMethodInfoStringL(

                    aIapIdToCompare, CMManager::EWlanSSID );

                if ( buffer->Compare( *bufferToCompare ) == 0 )

                    {

                    returnVal = ETrue;

                    }

                CleanupStack::PopAndDestroy( buffer );

                delete bufferToCompare;

                bufferToCompare = NULL;

                break;

            case KUidPacketDataBearerType:

                CCHUIDEBUG( "IsConnectionMethodSimilarL - KUidPacketDataBearerType" );

                buffer = iCmManagerExt.GetConnectionMethodInfoStringL(

                    aIapId, CMManager::EPacketDataAPName );

                CleanupStack::PushL( buffer );

                bufferToCompare = iCmManagerExt.GetConnectionMethodInfoStringL(

                    aIapIdToCompare, CMManager::EPacketDataAPName );

                if ( buffer->Compare( *bufferToCompare ) == 0 )

                    {

                    returnVal = ETrue;

                    }

                CleanupStack::PopAndDestroy( buffer );

                delete bufferToCompare;

                bufferToCompare = NULL;

                break;

            default:

			    CCHUIDEBUG( "IsConnectionMethodSimilarL - Bearer type unknown" );

                break;

            }

        }

    CCHUIDEBUG2(

        "CCchUiNotifConnectionHandler::IsConnectionMethodSimilarL -return = %d", returnVal );

    return returnVal;

    }