/*

* Copyright (c) 2006 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 of RCmConnectionMethodExt

*

*/

// INCLUDES

#include "cmmanagerimpl.h"

#include <cmdestinationext.h>

#include <cmpluginbase.h>

#include <cmconnectionmethodext.h>

#include "cmdestinationimpl.h"

using namespace CMManager;

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

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

// RCmConnectionMethodExt::RCmConnectionMethodExt()

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

//

EXPORT_C RCmConnectionMethodExt::RCmConnectionMethodExt(

                                const RCmConnectionMethodExt& aItem)

    : iImplementation( aItem.iImplementation )

    {

    iImplementation->IncrementRefCounter();

    }

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

// RCmConnectionMethodExt::Close()

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

//

EXPORT_C void RCmConnectionMethodExt::Close()

    {

    if( !iImplementation )

        {

        return;

        }

    TRAP_IGNORE( iImplementation->CmMgr().RemoveCMFromPoolL(iImplementation) );

    iImplementation = NULL;

    }

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

// RCmConnectionMethodExt::CreateCopyL()

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

//

EXPORT_C RCmConnectionMethodExt RCmConnectionMethodExt::CreateCopyL()

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    RCmConnectionMethodExt cm;

    cm.iImplementation = iImplementation->CreateCopyL();

    cm.iImplementation->CmMgr().InsertConnectionMethodL(cm.iImplementation);

    return cm;

    }

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

// RCmConnectionMethodExt::GetIntAttributeL()

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

//

EXPORT_C TUint32 

            RCmConnectionMethodExt::GetIntAttributeL( TUint32 aAttribute ) const

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    return iImplementation->GetIntAttributeL( aAttribute );

    }

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

// RCmConnectionMethodExt::GetBoolAttributeL()

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

//

EXPORT_C TBool 

           RCmConnectionMethodExt::GetBoolAttributeL( TUint32 aAttribute ) const

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    return iImplementation->GetBoolAttributeL( aAttribute );

    }

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

// RCmConnectionMethodExt::GetStringAttributeL()

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

//

EXPORT_C HBufC* 

        RCmConnectionMethodExt::GetStringAttributeL( TUint32 aAttribute ) const

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    return iImplementation->GetStringAttributeL( aAttribute );

    }

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

// RCmConnectionMethodExt::GetString8AttributeL()

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

//

EXPORT_C HBufC8* 

        RCmConnectionMethodExt::GetString8AttributeL( TUint32 aAttribute ) const

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    return iImplementation->GetString8AttributeL( aAttribute );

    }

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

// RCmConnectionMethodExt::SetIntAttributeL()

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

//

EXPORT_C void RCmConnectionMethodExt::SetIntAttributeL( TUint32 aAttribute, 

                                                        TUint32 aValue )

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    if( iImplementation->GetBoolAttributeL( ECmProtected ) )

        {

        // Only clients with NetworkControl capability can modify

        // protection setting!

        CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl );

        }

    iImplementation->SetIntAttributeL( aAttribute, aValue );

    }

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

// RCmConnectionMethodExt::SetBoolAttributeL()

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

//

EXPORT_C void RCmConnectionMethodExt::SetBoolAttributeL( TUint32 aAttribute, 

                                                         TBool aValue )

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    if( iImplementation->GetBoolAttributeL( ECmProtected ) )

        {

        // Only clients with NetworkControl capability can modify

        // protection setting!

        CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl );

        }

    iImplementation->SetBoolAttributeL( aAttribute, aValue );

    }

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

// RCmConnectionMethodExt::SetStringAttributeL()

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

//

EXPORT_C void 

            RCmConnectionMethodExt::SetStringAttributeL( TUint32 aAttribute, 

                                                         const TDesC16& aValue )

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    if( iImplementation->GetBoolAttributeL( ECmProtected ) )

        {

        // Only clients with NetworkControl capability can modify

        // protection setting!

        CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl );

        }

    iImplementation->SetStringAttributeL( aAttribute, aValue );

    }

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

// RCmConnectionMethodExt::SetString8AttributeL()

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

//

EXPORT_C void 

            RCmConnectionMethodExt::SetString8AttributeL( TUint32 aAttribute, 

                                                          const TDesC8& aValue )

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    if( iImplementation->GetBoolAttributeL( ECmProtected ) )

        {

        // Only clients with NetworkControl capability can modify

        // protection setting!

        CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl );

        }

    iImplementation->SetString8AttributeL( aAttribute, aValue );

    }

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

// RCmConnectionMethodExt::UpdateL()

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

//

EXPORT_C void RCmConnectionMethodExt::UpdateL()

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    iImplementation->UpdateL();

    }

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

// RCmConnectionMethodExt::DeleteL()

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

//

EXPORT_C TBool RCmConnectionMethodExt::DeleteL()

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }

    if( iImplementation->GetBoolAttributeL( ECmProtected ) )

        {

        // Only clients with NetworkControl capability can delete

        // this destination

        CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl );

        }

    // Check it's not connected

    if ( iImplementation->GetBoolAttributeL( ECmConnected ) )

        {

        User::Leave( KErrInUse );

        }

    // Check it's not referenced by Virtual CM

    if( iImplementation->GetBoolAttributeL( ECmIsLinked ) )

        {

        User::Leave( KErrLocked );

        }

    // Check that it's not the last CM in a destination which is

    // referenced by Virtual CM

    CCmDestinationImpl* destImpl = iImplementation->ParentDestination();

    TUint32 destId ( 0 );

    TUint32 count( 0 ); 

    if ( destImpl )

        {

        destId = destImpl->Id();

        count = destImpl->ConnectionMethodCount();

        }

    delete destImpl;

    destImpl = NULL;

    if ( count  == 1 )

        {

        // The IAP is in destination and it's the last one

            // for each IAP in CM manager

            //   1. check if it is virtual

            //      if not => goto 1.

            //      if yes:

            //      2. check if it links to the destination of this CM

            //         if yes => carryOn = EFalse, ERROR

            //         if not: carryOn = ETrue

        TBool carryOn = ETrue;

        CommsDat::CMDBRecordSet<CommsDat::CCDIAPRecord>* iaps = iImplementation->CmMgr().AllIapsL();

        CleanupStack::PushL( iaps );

        // for each IAP in CM manager

        for ( TInt i = KCmInitIndex; carryOn && i < iaps->iRecords.Count(); ++i )

            {

            CommsDat::CCDIAPRecord* rec = (*iaps)[i];

            TUint32 bearerType = 0;

            TRAP_IGNORE( bearerType = iImplementation->CmMgr().BearerTypeFromIapRecordL( rec ) );

            if ( !bearerType )

                {

                continue;

                }

            // check if it is virtual

            if ( iImplementation->CmMgr().GetBearerInfoBoolL( bearerType, ECmVirtual ) )

                {

                // check if it links to the current destination

                CCmPluginBase* plugin = NULL;            

                TRAP_IGNORE( plugin = iImplementation->CmMgr().GetConnectionMethodL( rec->RecordId() ) );

                if ( !plugin )

                    {

                    continue;

                    }

                if ( plugin->IsLinkedToSnap( destId ) )

                    {

                    // the CM links to this destination, deletion not allowed

                    carryOn = EFalse;

                    }

                delete plugin;

                }

            }

        CleanupStack::PopAndDestroy( iaps );

        if ( !carryOn )

            {

            User::Leave( KErrLocked );

            }

        }

    // ETrue = delete it. It doesn't matter how many referencies there are.

    TBool deleteRes = iImplementation->DeleteL( ETrue );

    if( deleteRes )

        {

        CCmDestinationImpl* dest = iImplementation->ParentDestination();

        if( dest )

            {

            CCmPluginBase* connMethod = new (ELeave) 

                                    CCmPluginBase(iImplementation);

            CleanupStack::PushL( connMethod );        

            dest->ConnectionMethodDeletedL( *connMethod );

            CleanupStack::PopAndDestroy(connMethod);//deletes iImplementation

            iImplementation = NULL;

            }

        delete dest;

        }

    return deleteRes;

    }

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

// RCmConnectionMethod::Destination()

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

//

EXPORT_C RCmDestinationExt RCmConnectionMethodExt::DestinationL() const

    {

    if (!iImplementation)

        {

        User::Leave(KErrBadHandle);

        }        

    if (!iImplementation->Destination())

        {

        User::Leave(KErrNotSupported);

        }

    RCmDestinationExt dest;

    dest.iDestinatonData = 

                iImplementation->Destination()->GetData();

    dest.iDestinatonData->IncrementRefCounter();

    return dest;

    }

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

// RCmConnectionMethod::RCmConnectionMethod

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

//

EXPORT_C RCmConnectionMethodExt::RCmConnectionMethodExt()

    : iImplementation( NULL )

    {

    }

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

// RCmConnectionMethodExt::~RCmConnectionMethodExt()

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

//

EXPORT_C RCmConnectionMethodExt::~RCmConnectionMethodExt()

    {

    Close();

    }

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

// RCmConnectionMethod::operator=()

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

//

EXPORT_C RCmConnectionMethodExt& RCmConnectionMethodExt::operator=(

                                const RCmConnectionMethodExt& aConnMethod)

    {

    if (this != &aConnMethod) 

        {

        Close();

        iImplementation = aConnMethod.iImplementation;

        iImplementation->IncrementRefCounter();

        }

    return *this;

    }

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

// RCmConnectionMethod::operator==

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

//

EXPORT_C TBool RCmConnectionMethodExt::operator==( 

                                    RCmConnectionMethodExt& aConnMethod ) const

    {

    return ( iImplementation == aConnMethod.iImplementation );

    };

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

// RCmConnectionMethod::operator!=

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

//

EXPORT_C TBool RCmConnectionMethodExt::operator!=( 

                                    RCmConnectionMethodExt& aConnMethod ) const

    {

    return !( iImplementation == aConnMethod.iImplementation );

    };