/*

* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 interface for WLAN services.

*

*/

/*

*/

#include <in_sock.h>

#include "wlandevicesettings.h"

#include "rwlmserver.h"

#include "wlmscanrequest.h"

#include "am_debug.h"

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

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

//

EXPORT_C void RWLMServer::ActivateNotifiesL(

    MWLMNotify& aCallback,

    TUint32 aNotificationMask )

    {

    DEBUG( "RWLMServer::ActivateNotifiesL()" );

    if( iNotify != NULL )

        {

        iNotify->Activate( aCallback, aNotificationMask );

        }

    else

        {

        iNotify = CWLMNotify::NewL( aCallback, *this, aNotificationMask );        

        }

    }

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

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

//

EXPORT_C void RWLMServer::CancelNotifies()

    {

    DEBUG( "RWLMServer::CancelNotifies()" );

    if( iNotify == NULL )

        {

        return;

        }

    if( iNotify->IsActive() )

        {

        // Notifications activated, request is pending

        iNotify->Cancel();

        }

    else

        {

        // Notifications activated, currently executing a notification

        //(i.e. in RunL of iNotify)

        iNotify->SetCancelled();

        }

    }

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

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

//

void RWLMServer::CancelRequest()

    {

    DEBUG( "RWLMServer::CancelRequest()" );

    // Check is notify service activated.

    if( iNotify != NULL )

        {

        // Send synchronous request to the data server

        DEBUG( "RWLMServer::CancelRequest() Cancelling..." );

        SendReceive( ECancelNotifications, TIpcArgs() );

        DEBUG( "Done!" );

        }

    else

        {

        DEBUG( "RWLMServer::CancelRequest() Notification service was not started." );

        }

    }

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

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

//

EXPORT_C void RWLMServer::Close()

    {

    DEBUG( "RWLMServer::Close()" );

    delete iNotify;

    iNotify = NULL;

    delete iScanRequest;

    iScanRequest = NULL;

    delete iTsCreateRequest;

    iTsCreateRequest = NULL;

    RHandleBase::Close();

    }

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

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

//

EXPORT_C TInt RWLMServer::Connect()

    {

    DEBUG( "RWLMServer::Connect()" );

    // Check that server is running

    TInt err = StartServer();

    if( err != KErrNone )

        {

        DEBUG1( "RWLMServer::Connect() - unable to start server (%d)",

            err );

        return err;

        }

    // Create a new session

    err = CreateSession( KWLMDataServerName, Version() );

    if( err != KErrNone )

        {

        DEBUG1( "RWLMServer::Connect() - unable to create a session (%d)",

            err );

        return err;

        }

    iNotify = NULL;        

    iScanRequest = NULL;

    iTsCreateRequest = NULL;

    TRAP( err, iScanRequest = CWlmScanRequest::NewL( *this ) );

    if ( err != KErrNone )

        {

        DEBUG1( "RWLMServer::Connect() - unable to create CWlmScanRequest (%d)",

            err );

        RHandleBase::Close();

        return err;

        }

    return KErrNone;

    }

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

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

//

EXPORT_C TInt RWLMServer::GetBSSID( TMacAddress& aBssid )

    {

    DEBUG( "RWLMServer::GetBSSID()" );

    TMacPckg mac;

    mac.data = KZeroMacAddr;

    TPckg<TMacPckg> inPckg( mac );

    TIpcArgs params( &inPckg );

    TInt ret = SendReceive( EGetMacAddress, params );

    if( ret == KErrNone )

        {

        Mem::Copy( &aBssid, &mac.data, sizeof( aBssid ) );

        }

    return ret;

    }

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

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

//

EXPORT_C TInt RWLMServer::GetNetworkName( TDes& aNwName )

    {

    DEBUG( "RWLMServer::GetNetworkName()" );

    // Get SSID from the server.

    TSSID ssid = { 0 };

    TPckg<TSSID> inPckg( ssid );

    TIpcArgs params( &inPckg );

    TInt ret = SendReceive( EGetNetworkName, params );

    if( ret == KErrNone )

        {

        // Convert it to text.    

        TBuf8<KMaxSsidStrLength> buf;

        buf.Format( _L8( "%s" ), ssid.ssid );

        buf.SetLength(

            ssid.ssidLength < static_cast<TUint>( aNwName.MaxLength() ) ? 

            ssid.ssidLength : 

            aNwName.MaxLength() );

        aNwName.Copy( buf );

        }

    return ret;

    }

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

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

//

EXPORT_C TWlanConnectionState RWLMServer::GetConnectionState()

    {

    DEBUG( "RWLMServer::GetConnectionState()" );

    // Call the server

    TWlanConnectionState connectionState( EWlanStateNotConnected );

    TPckg<TWlanConnectionState> outPckg( connectionState );

    TIpcArgs params( &outPckg );

    TInt ret = SendReceive( EGetCurrentState, params );

    if( ret != KErrNone )

        {

        return EConnectionStateUnknown;

        }

    else

        {

        return connectionState;

        }

    }

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

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

//

EXPORT_C TInt RWLMServer::GetConnectionRCPI( TInt32& aRCPI )

    {

    DEBUG( "RWLMServer::GetConnectionRCPI()" );

    TPckg<TInt32> inPckg( aRCPI );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetCurrentRSSI, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetSecurityMode( TWlanSecurity& aMode )

    {

    DEBUG( "RWLMServer::GetSecurityMode()" );

    TPckg<TWlanSecurity> inPckg( aMode );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetSecurityMode, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetSystemMode( TWlanSystemMode& aMode )

    {

    DEBUG( "RWLMServer::GetSystemMode()" );

    TPckg<TWlanSystemMode> inPckg( aMode );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetSystemMode, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetScanResults(

    ScanList& aResults,

    const TDesC8& aSsid,

    TInt& aCacheLifetime,

    TUint& aMaxDelay ) 

    {

    DEBUG( "RWLMServer::GetScanResults( aResults, aSsid, aCacheLifetime, aMaxDelay )" );

    return iScanRequest->IssueRequest(

        aResults,

        aSsid,

        aCacheLifetime,

        aMaxDelay,

        NULL );

    }

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

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

//

EXPORT_C void RWLMServer::GetScanResults(

    ScanList& aResults,

    const TDesC8& aSsid,

    TInt& aCacheLifetime,

    TUint& aMaxDelay,    

    TRequestStatus& aStatus )

    {

    DEBUG2( "RWLMServer::GetScanResults( aResults, aSsid, aCacheLifetime(%d), aMaxDelay(%u), aStatus )",

            aCacheLifetime, aMaxDelay );

    iScanRequest->IssueRequest(

        aResults,

        aSsid,

        aCacheLifetime,

        aMaxDelay,

        &aStatus );

    }

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

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

//

EXPORT_C void RWLMServer::CancelGetScanResults()

    {

    DEBUG( "RWLMServer::CancelGetScanResults()" );

    if ( iScanRequest->IsActive() )

        {

        iScanRequest->Cancel();

        // Complete the pending client request.

        TRequestStatus* status = iScanRequest->ClientStatus();        

        User::RequestComplete( status, KErrCancel );

        }

    }

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

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

//

EXPORT_C void RWLMServer::Join(

    TRequestStatus& aStatus, 

    const TUint32 aId, 

    TWLMOverrideSettings* aOverrides )

    {

    DEBUG( "RWLMServer::Join()" );

    // Use the override settings if necessary

    if( aOverrides )

        {

        iOverridePckg = *aOverrides;

        }

    else

        {

        // override settings not used

        TWLMOverrideSettings overrides;

        overrides.settingsMask = EOverrideNoneMask;

        iOverridePckg = overrides;

        }

    aStatus = KRequestPending;

    TIpcArgs params( reinterpret_cast<TAny*>( aId ), &iOverridePckg );

    // Send the command

    SendReceive( EJoinByProfileId, params, aStatus );    

    }

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

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

//

EXPORT_C void RWLMServer::CancelJoin()

    {

    DEBUG( "RWLMServer::CancelJoin()" );

    // Send the command

    SendReceive( ECancelJoin );

    }

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

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

//

EXPORT_C TInt RWLMServer::Release()

    {

    DEBUG( "RWLMServer::Release()" );

    return SendReceive( EReset, TIpcArgs() );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetAvailableIaps(

    TWlmAvailableIaps& aAvailableIaps,

    TInt& aCacheLifetime,

    TUint& aMaxDelay,

    TBool aFilteredResults )

    {

    DEBUG3( "RWLMServer::GetAvailableIaps( aAvailableIaps, aCacheLifetime(%d), aMaxDelay(%u), aFilteredResult(%u) )",

        aCacheLifetime, aMaxDelay, aFilteredResults );

    TRequestStatus status;

    TPckg<TWlmAvailableIaps> inPckg( aAvailableIaps );

    TPckg<TInt> inPckg2( aCacheLifetime );

    TPckg<TUint> inPckg3( aMaxDelay );

    GetAvailableIaps( inPckg, inPckg2, inPckg3, aFilteredResults, status );

    User::WaitForRequest( status );

    DEBUG1( "RWLMServer::GetAvailableIaps() - Server returned status %d", status.Int() );    

    return status.Int();

    }

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

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

//

EXPORT_C void RWLMServer::GetAvailableIaps( 

    TDes8& aAvailableIaps,

    TDes8& aCacheLifetime,

    TDes8& aMaxDelay,

    TBool aFilteredResults,

    TRequestStatus& aStatus )

    {

    DEBUG1( "RWLMServer::GetAvailableIaps( aAvailableIaps, aCacheLifetime, aMaxDelay, aFilteredResult(%u), aStatus )",

        aFilteredResults );

    aStatus = KRequestPending;

    TIpcArgs params( &aAvailableIaps, &aCacheLifetime, &aMaxDelay, aFilteredResults );

    SendReceive( EGetAvailableIaps, params, aStatus );

    }

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

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

//

EXPORT_C void RWLMServer::CancelGetAvailableIaps()

    {

    DEBUG( "RWLMServer::CancelGetAvailableIaps()" );

    // Send the command

    SendReceive( ECancelGetAvailableIaps );

    }

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

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

//

EXPORT_C void RWLMServer::NotifyChangedSettings()

    {

    DEBUG( "RWLMServer::NotifyChangedSettings()" );

    SendReceive( ENotifyChangedSettings, TIpcArgs() );

    }

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

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

//

EXPORT_C TInt RWLMServer::AddBssidToRoguelist( const TMacAddress& aBssid )

    {

    DEBUG( "RWLMServer::AddBssidToRoguelist()" );

    TMacPckg mac;

    Mem::Copy( &mac.data, &aBssid, sizeof( aBssid ) );

    TPckg<TMacPckg> inPckg( mac );

    TIpcArgs params( &inPckg );

    return SendReceive( EAddBssidToRoguelist, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::UpdateRcpNotificationBoundary(

    const TInt32 aRcpLevelBoundary,

    const TInt32 aHysteresis )

    {

    DEBUG2( "RWLMServer::UpdateRcpNotificationBoundary(): %d, %d", aRcpLevelBoundary, aHysteresis );

    TIpcArgs params( aRcpLevelBoundary, aHysteresis );

    return SendReceive( EUpdateRcpNotificationBoundaries, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::ConfigureMulticast(

    TUint aCommand,

    const TMacAddress& aMulticastAddress )

    {

    DEBUG1( "RWLMServer::ConfigureMulticast(): %d", aCommand );

    DEBUG_BUFFER( KMacAddressLength, aMulticastAddress.iMacAddress );

    TMacPckg mac;

    Mem::Copy( &mac.data, &aMulticastAddress, sizeof( aMulticastAddress ) );

    TPckg<TMacPckg> inPckg( mac );

    TIpcArgs params( &inPckg, aCommand );

    return SendReceive( EConfigureMulticastGroup, params );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetPacketStatistics(

    TWlanPacketStatistics& aStatistics )

    {

    DEBUG( "RWLMServer::GetPacketStatistics()" );

    TPckg<TWlanPacketStatistics> inPckg( aStatistics );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetPacketStatistics, params );

    }

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

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

//      

EXPORT_C void RWLMServer::ClearPacketStatistics()

    {

    DEBUG( "RWLMServer::ClearPacketStatistics()" );

    SendReceive( EClearPacketStatistics, TIpcArgs() );

    }

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

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

//

EXPORT_C TInt RWLMServer::GetUapsdSettings(

    TWlanUapsdSettings& aSettings )

    {

    DEBUG( "RWLMServer::GetUapsdSettings()" );

    TPckg<TWlanUapsdSettings> inPckg( aSettings );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetUapsdSettings, params );    

    }

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

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

//

EXPORT_C TInt RWLMServer::SetUapsdSettings(

    const TWlanUapsdSettings& aSettings )

    {

    DEBUG( "RWLMServer::SetUapsdSettings()" );

    TPckg<const TWlanUapsdSettings> inPckg( aSettings );

    TIpcArgs params( &inPckg );

    return SendReceive( ESetUapsdSettings, params );    

    }

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

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

//

EXPORT_C TInt RWLMServer::GetPowerSaveSettings(

    TWlanPowerSaveSettings& aSettings )

    {

    DEBUG( "RWLMServer::GetPowerSaveSettings()" );

    TPckg<TWlanPowerSaveSettings> inPckg( aSettings );

    TIpcArgs params( &inPckg );

    return SendReceive( EGetPowerSaveSettings, params );