/*

* Copyright (c) 2007 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:  CCCHServiceInfo implementation

*

*/

// INCLUDE FILES

#include "cchserviceinfo.h"

#include "cchsubserviceinfo.h"

#include "cchserverbase.h"

#include "cchpluginhandler.h"

#include "cchrequeststorage.h"

#include "cchspshandler.h"

#include "cchservicehandler.h"

#include "cchlogger.h"

#include "cchpluginhandler.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

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

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

// CCCHServiceInfo::CCCHServiceInfo

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCCHServiceInfo::CCCHServiceInfo( CCCHServerBase& aServer ):

    iServer( aServer ), 

    iReserved( ETrue )

    {

    // No implementation required

    }

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

// CCCHServiceInfo::NewL

// Two-phased constructor.

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

//

CCCHServiceInfo* CCCHServiceInfo::NewL( CCCHServerBase& aServer )

    {

    CCCHServiceInfo* self = CCCHServiceInfo::NewLC( aServer );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCCHServiceInfo::NewLC

// Two-phased constructor.

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

//

CCCHServiceInfo* CCCHServiceInfo::NewLC( CCCHServerBase& aServer )

    {

    CCCHServiceInfo* self = new (ELeave) CCCHServiceInfo( aServer );

    CleanupStack::PushL( self );

    return self;

    }

// Destructor

CCCHServiceInfo::~CCCHServiceInfo()

    {

    iSubservices.ResetAndDestroy();

    }

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

// CCCHServiceInfo::GetServiceId

// (other items were commented in a header).

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

//

TUint32 CCCHServiceInfo::GetServiceId() const

    {

    return iServiceId;

    }

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

// CCCHServiceInfo::SetServiceId

// (other items were commented in a header).

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

//

void CCCHServiceInfo::SetServiceId( TUint32 aServiceId )

    {

    iServiceId = aServiceId;

    }

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

// CCCHServiceInfo::GetName

// (other items were commented in a header).

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

//

const TDesC CCCHServiceInfo::GetName() const

    {

    return iServiceName;

    }

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

// CCCHServiceInfo::SetName

// (other items were commented in a header).

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

//

void CCCHServiceInfo::SetName( const TDesC& aName )

    {

    iServiceName.Copy( aName );

    }

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

// CCCHServiceInfo::EnableL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::EnableL( 

    const TCCHSubserviceType aServiceType, 

    const TBool aConnectivityCheck,

    MCCHServiceNotifier* aNotifier )

    {

    CCHLOGSTRING( "CCCHServiceInfo::EnableL: IN" );

    CCHLOGSTRING2( "CCCHServiceInfo::EnableL: ServiceId = %d", iServiceId );

    CCHLOGSTRING2( "CCCHServiceInfo::EnableL: iType %d", aServiceType );

    CCHLOGSTRING2( "CCCHServiceInfo::EnableL: connectivitycheck %d", 

        aConnectivityCheck );

    RArray<TUid> uids;

    CleanupClosePushL( uids );

    TUid pluginUid( KNullUid );

    TBool found( EFalse );

    TUint iapId( 0 );

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

        {

        pluginUid = iSubservices[ i ]->GetPluginUid();

        found = ( KErrNotFound != uids.Find( pluginUid ) );

        if ( !found && pluginUid != KNullUid && 

            ( ECCHUnknown == aServiceType ||

              aServiceType == iSubservices[ i ]->Type() ) )

            {

            uids.Append( pluginUid );

            }

        }

    0 < uids.Count() ? iServer.PluginHandler().EnableServiceL( 

        iServiceId, uids, aServiceType, aNotifier, iapId, aConnectivityCheck ) : 

            User::Leave( KErrNotFound );

    CleanupStack::PopAndDestroy( &uids );

    // Update service table

    if ( ECCHUnknown != aServiceType )

        {        

        iServer.SPSHandler().SetLoadAtStartUpL( iServiceId,

            aServiceType, ETrue );

        }

    else

        {

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

            {

            iServer.SPSHandler().SetLoadAtStartUpL( iServiceId,

            iSubservices[ i ]->Type(), ETrue );

            }

        }        

    CCHLOGSTRING( "CCCHServiceInfo::EnableL: OUT" );

    }

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

// CCCHServiceInfo::DisableL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::DisableL( const TCCHSubserviceType aServiceType )

    {

    CCHLOGSTRING( "CCCHServiceInfo::DisableL: IN" );

    CCHLOGSTRING2( "CCCHServiceInfo::DisableL: ServiceId = %d", iServiceId );

    CCHLOGSTRING2( "CCCHServiceInfo::DisableL: iType %d", aServiceType );

    RArray<TUid> uids;

    CleanupClosePushL( uids );

    TUid pluginUid( KNullUid );

    TBool found( EFalse );

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

        {

        pluginUid = iSubservices[ i ]->GetPluginUid();

        found = ( KErrNotFound != uids.Find( pluginUid ) );

        if ( !found && pluginUid != KNullUid && 

            ( ECCHUnknown == aServiceType ||

              aServiceType == iSubservices[ i ]->Type() ) )

            {

            uids.Append( pluginUid );

            }

        }

    0 < uids.Count() ? iServer.PluginHandler().DisableServiceL( 

        iServiceId, uids, aServiceType ) : User::Leave( KErrNotFound );

    CleanupStack::PopAndDestroy( &uids );

    // Update service table

    if ( ECCHUnknown != aServiceType )

        {        

        iServer.SPSHandler().SetLoadAtStartUpL( iServiceId,

            aServiceType, EFalse );

        }

    else

        {

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

            {

            iServer.SPSHandler().SetLoadAtStartUpL( iServiceId,

            iSubservices[ i ]->Type(), EFalse );

            }

        }

    CCHLOGSTRING( "CCCHServiceInfo::DisableL: OUT" );

    }

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

// CCCHServiceInfo::SetConnectionInfoL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::SetConnectionInfoL( 

    const TServiceConnectionInfo aServiceConnInfo )

    {

    CCHLOGSTRING( "CCCHServiceInfo::SetConnectionInfoL: IN" );

    RArray<TUid> uids;

    CleanupClosePushL( uids );

    TUid pluginUid( KNullUid );

    TBool found( EFalse );

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

        {        

        pluginUid = iSubservices[ i ]->GetPluginUid();

        found = ( KErrNotFound != uids.Find( pluginUid ) );

        if ( !found && pluginUid != KNullUid && 

            ( ECCHUnknown == aServiceConnInfo.iServiceSelection.iType ||

              aServiceConnInfo.iServiceSelection.iType == 

              iSubservices[ i ]->Type() ) )

            {

            uids.Append( pluginUid );

            }

        // Set connection information to subservice

        if ( ECCHUnknown == aServiceConnInfo.iServiceSelection.iType ||

              aServiceConnInfo.iServiceSelection.iType == 

              iSubservices[ i ]->Type() ) 

            {

            iSubservices[ i ]->SetIapId( aServiceConnInfo.iIapId );

            iSubservices[ i ]->SetSNAPId( aServiceConnInfo.iSNAPId );

            }

        }

    if ( 0 == uids.Count() )

        {

        User::Leave( KErrNotFound );

        }

    if ( !aServiceConnInfo.iIapId && aServiceConnInfo.iSNAPId )

        {

        iServer.PluginHandler().SetSnapIdL( 

            aServiceConnInfo.ServiceId(), uids, 

                aServiceConnInfo.Type(), 

                aServiceConnInfo.iSNAPId );

        }

    else if ( aServiceConnInfo.iIapId && !aServiceConnInfo.iSNAPId )

        {

        iServer.PluginHandler().SetIapIdL( 

            aServiceConnInfo.ServiceId(), uids, 

                aServiceConnInfo.Type(), 

                aServiceConnInfo.iIapId );

        }

    else if ( aServiceConnInfo.iIapId && aServiceConnInfo.iSNAPId )

        {

        iServer.PluginHandler().SetIapIdL( 

            aServiceConnInfo.ServiceId(), uids, 

                aServiceConnInfo.Type(),

                aServiceConnInfo.iIapId );

        iServer.PluginHandler().SetSnapIdL( 

            aServiceConnInfo.ServiceId(), uids, 

            aServiceConnInfo.Type(),

                aServiceConnInfo.iSNAPId );

        }

    // username must not be empty. And check this field should be set 

    if ( aServiceConnInfo.iServiceSelection.iParameter == ECchUsername && 

         aServiceConnInfo.iUsername.Length() )

        {

        iServer.PluginHandler().SetUsernameL( 

            aServiceConnInfo.ServiceId(), uids, 

                aServiceConnInfo.Type(), 

                aServiceConnInfo.iUsername );

        }

    // empty password is ok. And check this field should be set

    if ( aServiceConnInfo.iServiceSelection.iParameter == ECchPassword )

        {

        iServer.PluginHandler().SetPasswordL( 

            aServiceConnInfo.ServiceId(), uids, 

                aServiceConnInfo.Type(), 

                aServiceConnInfo.iPassword );

        }

    if ( aServiceConnInfo.iServiceSelection.iParameter == ECchReserved )

        {

        iReserved = aServiceConnInfo.iReserved;

        CCHLOGSTRING2( "CCCHServiceInfo::SetConnectionInfoL: reserved no action=%d", iReserved );

        }

    CleanupStack::PopAndDestroy( &uids );

    CCHLOGSTRING( "CCCHServiceInfo::SetConnectionInfoL: OUT" );

    }

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

// CCCHServiceInfo::GetConnectionInfoL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::GetConnectionInfoL( 

        TServiceConnectionInfo& aServiceConnInfo ) const

        {

        CCHLOGSTRING( "CCCHServiceInfo::GetConnectionInfoL: IN" );

        TUid pluginUid( KNullUid );

        TInt index( KErrNone );

        if ( aServiceConnInfo.iServiceSelection.iType != ECCHUnknown )

            {

            index = FindSubservice( aServiceConnInfo.iServiceSelection.iType );

            }

        if ( KErrNotFound != index && iSubservices.Count() )

            {

            pluginUid = iSubservices[ index ]->GetPluginUid();

            if( aServiceConnInfo.iServiceSelection.iParameter == ECchUsername )

                {

                const CCCHPluginHandler& ch = iServer.PluginHandler();

                const TServiceConnectionInfo& css = aServiceConnInfo;

                RBuf buffer; 

                buffer.CreateL(KCCHMaxProtocolNameLength);

                iServer.PluginHandler().GetConnectionParameter( 

                        pluginUid,

                        css.iServiceSelection, 

                        buffer );

                aServiceConnInfo.iUsername = buffer;

                buffer.Close();

                }

            else if( aServiceConnInfo.iServiceSelection.iParameter == 

                                                        ECchReserved )

                {

                CCHLOGSTRING2( "CCCHServiceInfo::GetConnectionInfoL: reserved no action=%d", iReserved );

                aServiceConnInfo.iReserved = iReserved;

                }

            else

                {

                User::LeaveIfError( iServer.PluginHandler().GetServiceNetworkInfo( 

                    aServiceConnInfo.ServiceId(), pluginUid, aServiceConnInfo.Type(), 

                        aServiceConnInfo.iSNAPId, aServiceConnInfo.iIapId, 

                        aServiceConnInfo.iSNAPLocked, aServiceConnInfo.iPasswordSet ) );                }

            }

        else

            {

            User::Leave( KErrNotFound );

            }

        CCHLOGSTRING( "CCCHServiceInfo::GetConnectionInfoL: OUT" );

    }

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

// CCCHServiceInfo::ReserveServiceL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::ReserveServiceL( 

    const TCCHSubserviceType aServiceType ) 

    {

    CCHLOGSTRING( "CCCHServiceInfo::ReserveServiceL: IN" );

    TUid pluginUid( KNullUid );

    TInt index( FindSubservice( aServiceType ) );

    if ( KErrNotFound != index )

        {

        pluginUid = iSubservices[ index ]->GetPluginUid();

        User::LeaveIfError( iServer.PluginHandler().ReserveService( 

            iServiceId, pluginUid, aServiceType ));

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CCHLOGSTRING( "CCCHServiceInfo::ReserveServiceL: OUT" );

    }

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

// CCCHServiceInfo::FreeServiceL

// (other items were commented in a header).

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

//

void CCCHServiceInfo::FreeServiceL( 

    const TCCHSubserviceType aServiceType )

    {

    CCHLOGSTRING( "CCCHServiceInfo::FreeServiceL: IN" );

    TUid pluginUid( KNullUid );

    TInt index( FindSubservice( aServiceType ) );

    if ( KErrNotFound != index )

        {

        pluginUid = iSubservices[ index ]->GetPluginUid();

        User::LeaveIfError( iServer.PluginHandler().FreeService( 

            iServiceId, pluginUid, aServiceType ));

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CCHLOGSTRING( "CCCHServiceInfo::FreeServiceL: OUT" );

    }

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

// CCCHServiceInfo::IsReservedL

// (other items were commented in a header).

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

//

TBool CCCHServiceInfo::IsReservedL( 

    const TCCHSubserviceType aServiceType ) const

    {

    CCHLOGSTRING( "CCCHServiceInfo::IsReservedL: IN" );

    TBool ret(EFalse);

    TUid pluginUid( KNullUid );

    TInt index( FindSubservice( aServiceType ) );

    if ( KErrNotFound != index )

        {

        pluginUid = iSubservices[ index ]->GetPluginUid();

        User::LeaveIfError( ret = iServer.PluginHandler().IsReserved( 

            iServiceId, pluginUid, aServiceType ));

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CCHLOGSTRING( "CCCHServiceInfo::IsReservedL: OUT" );

    return ret;

    }         

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

// CCCHServiceInfo::IsEnabled

// (other items were commented in a header).

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

//

TBool CCCHServiceInfo::IsEnabled() const

    {

    return iIsEnabled;

    }

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

// CCCHServiceInfo::AddSubservice

// (other items were commented in a header).

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

//

void CCCHServiceInfo::AddSubserviceL( TCCHSubservice& aSubservice )

    {

    CCHLOGSTRING( "CCCHServiceInfo::AddSubserviceL: IN" );

    CCCHSubserviceInfo* subserviceInfo = NULL;

    if ( ECCHUnknown != aSubservice.iConnectionInfo.iServiceSelection.iType )

        {

        // Create new instance and set service id

        subserviceInfo = 

            CCCHSubserviceInfo::NewL( aSubservice.iConnectionInfo.iServiceSelection.iServiceId, iServer );

        // Set subserviceID

        subserviceInfo->SetSubserviceId( aSubservice.iSubserviceId );

        // Get plugin uid from service table

        TUid pUid( KNullUid );

        iServer.SPSHandler().GetConnectivityPluginUidL( 

                aSubservice.iConnectionInfo.iServiceSelection.iServiceId, aSubservice.iConnectionInfo.iServiceSelection.iType, pUid ); 

        subserviceInfo->SetPluginUid( pUid );