/*
* Copyright (c) 2007-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:  Implementation of TWsfWlanInfo
*
*/



//  EXTERNAL INCLUDES
#include <utf.h>
#include <s32strm.h>

//  CLASS HEADER
#include "wsfwlaninfo.h"


using namespace CMManager;


// Percentage max value
static const TInt KMaxPercentage = 100;



// ---------------------------------------------------------------------------
// TWsfWlanInfo::TWsfWlanInfo
// ---------------------------------------------------------------------------
//    
EXPORT_C TWsfWlanInfo::TWsfWlanInfo():
    iSsid( KNullDesC8 ),
	iStrengthLevel( EWlanSignalUnavailable ),
    iSecurityMode( EWlanSecModeOpen ),
    iVisibility( EFalse ),
    iNetMode( EAdhoc ),
    iIapId( 0 ),
    iCoverage( 0 ),
    iTransferRate( 0 ),
    iConnectionState( ENotConnected ),
    iFilterFlags( 0 ),
    iBrandId( 0 ),
    iNetworkName( KNullDesC8 ),
    iPriority ( 0 )
    {
    }


// ---------------------------------------------------------------------------
// TWsfWlanInfo::TWsfWlanInfo
// ---------------------------------------------------------------------------
//    
EXPORT_C TWsfWlanInfo::TWsfWlanInfo( TDesC8& aSsid,
                        TUint16 aStrengthLevel,
                        TWlanSecMode aSecurityMode,
                        TInt aVisibility,
                        TWlanNetMode aNetMode,
                        TUint32 aIapId,
                        TUint8 aCoverage,
                        TUint32 aTransferRate ):
    iSsid( aSsid ),
    iStrengthLevel( aStrengthLevel ),
    iSecurityMode( aSecurityMode ),
    iVisibility( aVisibility ),
    iNetMode( aNetMode ),
    iIapId( aIapId ),
    iCoverage( aCoverage ),
    iTransferRate( aTransferRate ),
    iConnectionState( ENotConnected ),
    iFilterFlags( 0 ),
    iBrandId( 0 ),
    iPriority( 0 )
    {
    }

// ---------------------------------------------------------------------------
// TWsfWlanInfo::GetSsidAsUnicodeLC
// ---------------------------------------------------------------------------
//    
EXPORT_C HBufC* TWsfWlanInfo::GetSsidAsUnicodeLC()
    {
    return GetSsidAsUnicodeLC( iSsid );
    }


// ---------------------------------------------------------------------------
// TWsfWlanInfo::GetSsidAsUnicodeLC
// ---------------------------------------------------------------------------
//    
EXPORT_C HBufC* TWsfWlanInfo::GetSsidAsUnicodeLC( const TWlanSsid& aSsid )
    {
    HBufC* ssid = HBufC::NewLC( aSsid.Length() );
    TPtr ptr = ssid->Des();
    TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8( ptr, aSsid );
    if ( err != KErrNone )
        {
        // If ssid wasn't utf-8 encoded, assume it unicode already
        // it's not specified how WLAN SSIDs should be encoded.
        ptr.Copy( aSsid );
        }
    return ssid;
    }


// ---------------------------------------------------------------------------
// TWsfWlanInfo::GetSsidAsUtf8LC
// ---------------------------------------------------------------------------
//    
EXPORT_C HBufC8* TWsfWlanInfo::GetSsidAsUtf8LC()
    {
    HBufC8* ssid = iSsid.AllocLC();
    return ssid;
    }


// ---------------------------------------------------------------------------
// TWsfWlanInfo::InternalizeL
// ---------------------------------------------------------------------------
//    
EXPORT_C void TWsfWlanInfo::InternalizeL( RReadStream& aStream )
	{
	aStream >> iSsid;
	iStrengthLevel = aStream.ReadInt16L();
	iSecurityMode = TWlanSecMode( aStream.ReadInt32L() );
	iVisibility = aStream.ReadInt8L();
	iNetMode = TWlanNetMode( aStream.ReadInt32L() );
	iIapId = aStream.ReadInt32L();
	iCoverage = aStream.ReadInt8L();
	iTransferRate = aStream.ReadInt32L();
	iConnectionState = TWsfWlanConnectionState( aStream.ReadInt8L() );
	iFilterFlags = aStream.ReadInt8L();
	iBrandId = aStream.ReadInt8L();
	iPriority = aStream.ReadInt8L();
	aStream >> iNetworkName;
	}


// ---------------------------------------------------------------------------
// TWsfWlanInfo::ExternalizeL
// ---------------------------------------------------------------------------
//    
EXPORT_C void TWsfWlanInfo::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << iSsid;
	aStream.WriteInt16L( iStrengthLevel );
	aStream.WriteInt32L( iSecurityMode );
	aStream.WriteInt8L( iVisibility );
	aStream.WriteInt32L( iNetMode );
	aStream.WriteInt32L( iIapId );
	aStream.WriteInt8L( iCoverage );
	aStream.WriteInt32L( iTransferRate );
	aStream.WriteInt8L( iConnectionState );
	aStream.WriteInt8L( iFilterFlags );
	aStream.WriteInt8L( iBrandId );
	aStream.WriteInt8L( iPriority );
	aStream << iNetworkName;
	}


// ---------------------------------------------------------------------------
// TWsfWlanInfo::SignalStrength
// ---------------------------------------------------------------------------
//    
EXPORT_C TWsfWlanSignalStrengthLevel TWsfWlanInfo::SignalStrength()
	{
	// check the absolute signal level and return symbolic representation
	// smaller value means stronger signal
	TWsfWlanSignalStrengthLevel level( EAverage );
	
    if ( iStrengthLevel < EWlanSignalStrengthGood )
        {
        level = EExcelent;
        }
    else if ( iStrengthLevel > EWlanSignalStrengthLow )
        {
        if ( iStrengthLevel == EWlanSignalUnavailable )
            {
            level = ENoSignal;
            }
        else
            {
            level = EPoor;
            }
        }

    return level;
	}


// ---------------------------------------------------------------------------
// TWsfWlanInfo::SignalStrengthPercentage
// ---------------------------------------------------------------------------
//    
EXPORT_C TInt TWsfWlanInfo::SignalStrengthPercentage()
	{
	// smaller value means stronger signal
	TInt signalStrength( 0 );
	
    if ( iStrengthLevel <= EWlanSignalStrengthMax )
        {
        signalStrength = KMaxPercentage;
        }
    else if ( iStrengthLevel < EWlanSignalStrengthMin )
        {
        TInt diff = EWlanSignalStrengthMin - iStrengthLevel;
        signalStrength = diff * KMaxPercentage / 
                           ( EWlanSignalStrengthMin - EWlanSignalStrengthMax );
        }
        
    return signalStrength;
	}


// ---------------------------------------------------------------------------
// TWsfWlanInfo::GetSsidAsUnicodeLC
// ---------------------------------------------------------------------------
//    
EXPORT_C HBufC* TWsfWlanInfo::GetIapNameAsUnicodeLC()
    {
    // This is essentially the same as ssid conversion
    return GetSsidAsUnicodeLC( iNetworkName );
    }


// ---------------------------------------------------------------------------
// TWsfWlanInfo::GetSsidAsUtf8LC
// ---------------------------------------------------------------------------
//    
EXPORT_C HBufC8* TWsfWlanInfo::GetIapNameAsUtf8LC()
    {
    HBufC8* networkName = iNetworkName.AllocLC();
    return networkName;
    }


// End of file