/*

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

 * This is a source file for CmmWrapperPrivate class.

 */

// INCLUDE FILES

#include <e32base.h>

#include <cmmanagerdef.h>

#include <cmconnectionmethodext.h>

#include <cmdestinationext.h>

#include <cmpluginwlandef.h>

#include "wlanqtutilscommon.h"

#include "wlanqtutilsiap.h"

#include "wlanqtutilswlanap.h"

#include "wlanqtutilswlaniap.h"

#include "wlanqtutilscmmwrapper.h"

#include "wlanqtutilscmmwrapper_s60_p.h"

#ifdef WLANQTUTILS_NO_OST_TRACES_FLAG

#include <opensystemtrace.h>

#else

#include "OstTraceDefinitions.h"

#endif

#ifdef OST_TRACE_COMPILER_IN_USE

#include "wlanqtutilscmmwrapper_s60Traces.h"

#endif

// =========== PRIVATE CLASS MEMBER FUNCTIONS ===============

//

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

// CmmWrapperPrivate::CmmWrapperPrivate()

// Constructor

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

//

CmmWrapperPrivate::CmmWrapperPrivate(CmmWrapper *wrapper) :

    q_ptr(wrapper)

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_CMMWRAPPERPRIVATE_ENTRY, this );

    TRAPD(err, iCmManagerExt.OpenL());

    if (err != KErrNone) {

        // todo

    }

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_CMMWRAPPERPRIVATE_EXIT, this );

    }

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

// CmmWrapperPrivate::CmmWrapperPrivate()

// Destructor

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

//

CmmWrapperPrivate::~CmmWrapperPrivate()

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_CMMWRAPPERPRIVATEDESTR_ENTRY, this );

    iCmManagerExt.Close();

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_CMMWRAPPERPRIVATEDESTR_EXIT, this );

    }

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

// CmmWrapperPrivate::fetchIaps()

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

//

int CmmWrapperPrivate::fetchIaps(QList<WlanQtUtilsIap*>& iapList)

    {    

    TRAPD(err, fetchIapsL(iapList));

    return err;

    }

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

// CmmWrapperPrivate::fetchIapsL()

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

//

void CmmWrapperPrivate::fetchIapsL(QList<WlanQtUtilsIap*>& iapList)

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_FETCHIAPSL_ENTRY, this );

    // reset the list, just in case

    iapList.clear();

    //Array granularity 10

    RArray<TUint32> destinationIdArray = RArray<TUint32> (10);

    destinationIdArray.Reset();

    iCmManagerExt.AllDestinationsL(destinationIdArray);

    // looping all the SNAPs through

    QList<WlanQtUtilsIap*> snapsIapList;

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

        {

        snapsIapList.clear();

        RCmDestinationExt dest;

        dest = iCmManagerExt.DestinationL(destinationIdArray[i]);

        TUint32 id = dest.Id();

        if (getIapListFromSnap(id, snapsIapList) == KErrNone)

            {

            iapList.append(snapsIapList);

            }

        }

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_FETCHIAPSL_EXIT, this );

    }

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

// CmmWrapperPrivate::createWlanIap()

// Creates a new WLAN IAP

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

//

WlanQtUtilsWlanIap *CmmWrapperPrivate::createWlanIap(const WlanQtUtilsWlanAp *aWlanAp)

    {

    WlanQtUtilsWlanIap *iap = NULL;

    TRAPD(err, iap = createWlanIapL(aWlanAp));

    if (err != KErrNone)

        {

        // Todo: trace

        }

    return iap;

    }

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

// CmmWrapperPrivate::createWlanIapL()

// Creates a new WLAN IAP

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

//

WlanQtUtilsWlanIap *CmmWrapperPrivate::createWlanIapL(const WlanQtUtilsWlanAp *aWlanAp)

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_CREATEWLANIAPL_ENTRY, this );

    // Create the new IAP

    RCmConnectionMethodExt plugin = iCmManagerExt.CreateConnectionMethodL(

            KUidWlanBearerType);

    CleanupClosePushL(plugin);

    // Convert QString to Symbian buffer

    TBufC<KMaxSsidLen> buffer(aWlanAp->ssid().utf16());

    WlanQtUtilsWlanSecMode secMode = aWlanAp->securityMode();

    int cmManagersSecMode = wlanQtUtils2CmmSecModeMap(secMode);

    plugin.SetStringAttributeL(CMManager::ECmName, buffer);

    plugin.SetStringAttributeL(CMManager::EWlanSSID, buffer);

    plugin.SetIntAttributeL(CMManager::EWlanSecurityMode, cmManagersSecMode);

    // Todo: other parameters such as security keys

#if 0

    // TODO the security settings API plugin needs to be initialized here

    // with the iap id.

    // Check if the key value has been given

    QString key = aWlanAp->securityKey();

    if ( key.length() > 0 )

        {

        // Set the security key values here

        if ( secMode == CMManager::EWlanSecModeWpa || 

             secMode == CMManager::EWlanSecModeWpa2 )

            {

            // Store the WPA key to the database using the security settings API

            TBufC<KMaxWEPKeyLen> bufKey(key.utf16());

            plugin.SetStringAttributeL( CMManager::EWlanWpaPreSharedKey, bufKey );

            }

        else if ( secMode == CMManager::EWlanSecModeWep )

            {

            // Store the WPA key to the database using the security settings API

            TBufC<KMaxWPAKeyLen> bufKey(key.utf16());

            plugin.SetStringAttributeL( CMManager::EWlanWepKey1, bufKey );

            }

        }

#endif

    plugin.UpdateL();

    TInt iapId = plugin.GetIntAttributeL(CMManager::ECmIapId);

    CleanupStack::PopAndDestroy(&plugin); // Close() called on "plugin"

    // Read details of the new IAP and create the WLAN IAP class

    RCmConnectionMethodExt connectionMethod = iCmManagerExt.ConnectionMethodL( iapId );

    WlanQtUtilsIap *newIap = getIapInfoL(connectionMethod);

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_CREATEWLANIAPL_EXIT, this );

    return qobject_cast<WlanQtUtilsWlanIap *>(newIap);

    }

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

// CmmWrapperPrivate::moveIapToInternetSnap()

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

//

void CmmWrapperPrivate::moveIapToInternetSnap( TInt32 aIapId )

    {

    TRAPD( err, moveIapToInternetSnapL( aIapId ) );

    if (err != KErrNone)

        {

        // todo: add trace

        }

    }

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

// CmmWrapperPrivate::moveIapToInternetSnapL()

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

//

void CmmWrapperPrivate::moveIapToInternetSnapL( TInt32 aIapId )

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_MOVEIAPTOINTERNETSNAPL_ENTRY, this );

    // Read all destination(SNAP) settings into an array

    RArray<TUint32> destinations;

    CleanupClosePushL(destinations);

    iCmManagerExt.AllDestinationsL(destinations);

    RCmDestinationExt destination;

    // Loop through each destination

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

        {

        destination = iCmManagerExt.DestinationL(destinations[i]);

        CleanupClosePushL(destination); 

        // Internet destination will always exist in the system.

        // Internet destination will have ESnapPurposeInternet set in its metadata.

        if (destination.MetadataL(CMManager::ESnapMetadataPurpose) == CMManager::ESnapPurposeInternet)

            {

            RCmConnectionMethodExt iap = iCmManagerExt.ConnectionMethodL( aIapId );

            CleanupClosePushL( iap );        

            destination.AddConnectionMethodL( iap );

            destination.UpdateL();

            CleanupStack::PopAndDestroy(); // iap

            }

        CleanupStack::PopAndDestroy(); // destination

        }

    CleanupStack::PopAndDestroy(); // destinations

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_MOVEIAPTOINTERNETSNAPL_EXIT, this );

    }

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

// CmmWrapperPrivate::getIapListFromSnap()

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

//

int CmmWrapperPrivate::getIapListFromSnap(TUint32 aDestId,

        QList<WlanQtUtilsIap*>& iapList)

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_GETIAPLISTFROMSNAP_ENTRY, this );

    RCmDestinationExt dest;

    TRAPD(err, dest = iCmManagerExt.DestinationL(aDestId));

    if (err != KErrNone)

        {

        OstTraceFunctionExit1( CMMWRAPPERPRIVATE_GETIAPLISTFROMSNAP_EXIT, this );

        return err;

        }

    // Copy IAPs from the SNAP into iapList.

    int destIapCount = dest.ConnectionMethodCount();

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

        {

        WlanQtUtilsIap* iap = NULL;

        TRAP(err, iap = getIapInfoL(dest.ConnectionMethodL(i)));

        if (err == KErrNone)

            {

            iapList.append(iap);

            }

        }

    OstTraceFunctionExit1( DUP1_CMMWRAPPERPRIVATE_GETIAPLISTFROMSNAP_EXIT, this );

    return err;

    }

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

// CmmWrapperPrivate::getIapInfoL()

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

//

WlanQtUtilsIap *CmmWrapperPrivate::getIapInfoL(

    RCmConnectionMethodExt aConnectionMethod)

    {

    OstTraceFunctionEntry1( CMMWRAPPERPRIVATE_GETIAPINFOL_ENTRY, this );

    TUint iapId = aConnectionMethod.GetIntAttributeL(CMManager::ECmIapId);

    TUint netId = aConnectionMethod.GetIntAttributeL(CMManager::ECmNetworkId);

    HBufC* iapName = aConnectionMethod.GetStringAttributeL(CMManager::ECmName);

    TUint iapBearerType = aConnectionMethod.GetIntAttributeL(CMManager::ECmBearerType);

    QString name = QString::fromUtf16(iapName->Ptr(), iapName->Length());

    WlanQtUtilsBearerType bearer;

    WlanQtUtilsIap* newIap = NULL;

    if (iapBearerType == KUidPacketDataBearerType)

        {

        bearer = WlanQtUtilsBearerTypeCellular;

        newIap = new WlanQtUtilsIap(iapId, netId, name, bearer);

        }

    else

        {

        TInt secModeFromCmManager =

                aConnectionMethod.GetIntAttributeL(CMManager::EWlanSecurityMode);

        WlanQtUtilsWlanSecMode secMode = cmm2WlanQtUtilsSecModeMap(secModeFromCmManager);

        bearer = WlanQtUtilsBearerTypeWlan;

        //Note ssid is set same as iap name

        WlanQtUtilsWlanIap* wlanIap = 

            new WlanQtUtilsWlanIap(iapId, netId, name, bearer, name, secMode);

        newIap = wlanIap;

        }

    OstTraceFunctionExit1( CMMWRAPPERPRIVATE_GETIAPINFOL_EXIT, this );

    return newIap;

    }

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

// CmmWrapperPrivate::cmm2WlanQtUtilsSecModeMap()

// Maps CMManager's WLAN security mode into WlanQtUtilsWlanSecMode.

// CMManager uses sec mode type TConnMonSecurityMode defined

// in rconnmon.h.

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

//

WlanQtUtilsWlanSecMode CmmWrapperPrivate::cmm2WlanQtUtilsSecModeMap(int aSecModeFromCmManager)

    {

    WlanQtUtilsWlanSecMode ret;

    switch (aSecModeFromCmManager)

        {

        case CMManager::EWlanSecModeWep:

            ret = WlanQtUtilsWlanSecModeWep;

            break;

        case CMManager::EWlanSecMode802_1x:

            ret = WlanQtUtilsWlanSecMode802_1x;

            break;

        case CMManager::EWlanSecModeWpa:

            ret = WlanQtUtilsWlanSecModeWpa;

            break;

        case CMManager::EWlanSecModeWpa2:

            ret = WlanQtUtilsWlanSecModeWpa2;

            break;

        default:

            ret = WlanQtUtilsWlanSecModeOpen;

            break;

        }

    return ret;

    }

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

// Maps WlanQtUtilsWlanSecMode into CMManager's WLAN security mode

// (TWlanSecMode, defined in cmpluginwlandef.h).

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

//

int CmmWrapperPrivate::wlanQtUtils2CmmSecModeMap(WlanQtUtilsWlanSecMode aWlanQtUtilsSecMode)

    {

    int ret;

    switch (aWlanQtUtilsSecMode)

        {

        case WlanQtUtilsWlanSecModeWep:

            ret = CMManager::EWlanSecModeWep;

            break;

        case WlanQtUtilsWlanSecMode802_1x:

            ret = CMManager::EWlanSecMode802_1x;

            break;

        case WlanQtUtilsWlanSecModeWpa:

            ret = CMManager::EWlanSecModeWpa;

            break;

        case WlanQtUtilsWlanSecModeWpa2:

            ret = CMManager::EWlanSecModeWpa2;

            break;

        default:

            ret = CMManager::EWlanSecModeOpen;

            break;

        }

    return ret;

    }

//end of file