/*
* Copyright (c) 2006-2008 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 for the CConnMonWlanNetwork class.
*
*/

#include <e32cmn.h>
#include <rconnmon.h>

#include "ConnMonUtils.h"
#include "log.h"

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

// ---------------------------------------------------------------------------
//  Constructor
// ---------------------------------------------------------------------------
//
CConnMonWlanNetwork::CConnMonWlanNetwork()
    {
    }

// ---------------------------------------------------------------------------
//  Constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CConnMonWlanNetwork* CConnMonWlanNetwork::NewL()
    {
    CConnMonWlanNetwork* self = new( ELeave ) CConnMonWlanNetwork();
    return self;
    }

// ---------------------------------------------------------------------------
//  Constructor
// ---------------------------------------------------------------------------
//
CConnMonWlanNetwork::CConnMonWlanNetwork(
        const TBuf<KMaxNameLength>& aName,
        TUint aConnectionMode,
        TUint aSignalStrength,
        TUint aSecurityMode,
        const TBuf8<KWlanBssId>& aBssId,
        const TDesC& aVendorData )
        :
        iName( aName ),
        iConnectionMode( aConnectionMode ),
        iSignalStrength( aSignalStrength ),
        iSecurityMode( aSecurityMode ),
        iWlanBssId( aBssId ),
        iVendorData( NULL )
    {
    if ( aVendorData != KNullDesC() && aVendorData.Length() > 0 )
        {
        // Can't leave here, copy contents only if enough memory
        iVendorData = HBufC::New( aVendorData.Length() );
        if ( iVendorData )
            {
            iVendorData->Des().Copy( aVendorData );
            }
        }
    }

// ---------------------------------------------------------------------------
//  Constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CConnMonWlanNetwork* CConnMonWlanNetwork::NewL(
        const TBuf<KMaxNameLength>& aName,
        TUint aConnectionMode,
        TUint aSignalStrength,
        TUint aSecurityMode,
        const TBuf8<KWlanBssId>& aBssId,
        const TDesC& aVendorData )
    {
    CConnMonWlanNetwork* wlanNet = new( ELeave ) CConnMonWlanNetwork(
            aName,
            aConnectionMode,
            aSignalStrength,
            aSecurityMode,
            aBssId,
            aVendorData );

    return wlanNet;
    }

// ---------------------------------------------------------------------------
//  Second-phase constructor
// ---------------------------------------------------------------------------
//
void CConnMonWlanNetwork::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
//  Copy Constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CConnMonWlanNetwork* CConnMonWlanNetwork::NewL(
        CConnMonWlanNetwork& aConnMonWlanNetwork )
    {
    CConnMonWlanNetwork* wlanNet;
    if ( aConnMonWlanNetwork.iVendorData )
        {
        wlanNet = new( ELeave ) CConnMonWlanNetwork(
                aConnMonWlanNetwork.iName,
                aConnMonWlanNetwork.iConnectionMode,
                aConnMonWlanNetwork.iSignalStrength,
                aConnMonWlanNetwork.iSecurityMode,
                aConnMonWlanNetwork.iWlanBssId,
                aConnMonWlanNetwork.iVendorData->Des() );
        }
    else
        {
        wlanNet = new( ELeave ) CConnMonWlanNetwork(
                aConnMonWlanNetwork.iName,
                aConnMonWlanNetwork.iConnectionMode,
                aConnMonWlanNetwork.iSignalStrength,
                aConnMonWlanNetwork.iSecurityMode,
                aConnMonWlanNetwork.iWlanBssId,
                KNullDesC() );
        }
    return wlanNet;
    }

// ---------------------------------------------------------------------------
//  Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CConnMonWlanNetwork::~CConnMonWlanNetwork()
    {
    delete iVendorData;
    }

// ---------------------------------------------------------------------------
//  = operator
// ---------------------------------------------------------------------------
//
EXPORT_C CConnMonWlanNetwork& CConnMonWlanNetwork::operator=(
        CConnMonWlanNetwork& aConnMonWlanNetwork )
    {
    TInt err( KErrNone );

    iName.Copy( aConnMonWlanNetwork.Name() );
    iConnectionMode = aConnMonWlanNetwork.ConnectionMode();
    iSignalStrength = aConnMonWlanNetwork.SignalStrength();
    iSecurityMode = aConnMonWlanNetwork.SecurityMode();
    iWlanBssId = aConnMonWlanNetwork.WlanBssid();

    if ( aConnMonWlanNetwork.iVendorData )
        {
        delete iVendorData;
        iVendorData = NULL;
        TRAP( err, iVendorData = HBufC::NewL( aConnMonWlanNetwork.iVendorData->Length() ) );
        if ( err )
            {
            LOGIT1("VendorData handling error <%d>", err)
            }
        else
            {
            iVendorData = aConnMonWlanNetwork.iVendorData;
            }
        }
    return *this;
    }

// ---------------------------------------------------------------------------
// Compares two networks by iSignalStrength
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CConnMonWlanNetwork::CompareBySignal(
        const CConnMonWlanNetwork& aFirst,
        const CConnMonWlanNetwork& aSecond )
    {
    //LOGENTRFN("CConnMonWlanNetwork::CompareBySignal()")

    TInt rc( 0 );
    if ( aFirst.iSignalStrength > aSecond.iSignalStrength )
        {
        rc = 1;
        }
    else if ( aFirst.iSignalStrength < aSecond.iSignalStrength )
        {
        rc = -1;
        }

    //LOGEXITFN1("CConnMonWlanNetwork::CompareBySignal()", rc)
    return rc;
    }

// ---------------------------------------------------------------------------
// Packages object to HBufC descriptor
// ---------------------------------------------------------------------------
//
EXPORT_C const HBufC* CConnMonWlanNetwork::ToBuf() const
    {
    //LOGENTRFN("CConnMonWlanNetwork::ToBuf()")

    // Check the vendor data length
    TInt vendorDataSize( 0 );
    if ( iVendorData )
        {
        vendorDataSize = iVendorData->Length();
        }

    // Allocate buffer to "all" data
    HBufC* buf = HBufC::New( sizeof( CConnMonWlanNetwork ) + vendorDataSize );
    if ( !buf )
        {
        LOGIT("ToBuf: out of memory error")
        }
    else
        {
        TPtr ptr( buf->Des() );

        // Add CConnMonWlanNetwork object
        ptr.Copy( (TUint16*)this, (TInt)sizeof( CConnMonWlanNetwork ) / sizeof( TUint16 ) );

        // If vendor data exists, add it also
        if ( vendorDataSize > 0 )
            {
            ptr.Append( iVendorData->Des() );
            }
        }

    //LOGEXITFN("CConnMonWlanNetwork::ToBuf()")
    return buf;
    }

// ---------------------------------------------------------------------------
// Unpackages CConnMonWlanNetwork from TPtrC descriptor
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CConnMonWlanNetwork::FromPtrC(
        const TPtrC& aPtrC,
        CConnMonWlanNetwork* aConnMonWlanNetwork )
    {
    //LOGENTRFN("CConnMonWlanNetwork::FromPtrC()")
    TInt err( KErrNone );

    // Copy CConnMonWlanNetwork object data from the beginning of aPtrC
    memcpy( aConnMonWlanNetwork, aPtrC.Ptr(), sizeof( CConnMonWlanNetwork ) );

    // Reset vendor data pointer
    aConnMonWlanNetwork->iVendorData = NULL;

    // If vendor data exists, allocate memory and read it (it exists just after
    // CConnMonWlanNetwork object data) from aPtrC
    if ( aPtrC.Length() > sizeof( CConnMonWlanNetwork ) )
        {
        TInt vendorDataLen = aPtrC.Length() - sizeof( CConnMonWlanNetwork );

        aConnMonWlanNetwork->iVendorData = HBufC::New( vendorDataLen );
        if ( !aConnMonWlanNetwork->iVendorData )
            {
            err = KErrNoMemory;
            LOGIT("FromPtrC: out of memory error")
            }
        else
            {
            aConnMonWlanNetwork->iVendorData->Des().Copy(
                    aPtrC.Mid( sizeof( CConnMonWlanNetwork ), vendorDataLen ) );
            }
        }

    //LOGEXITFN1("CConnMonWlanNetwork::FromPtrC()", err)
    return err;
    }

// End-of-file