/*

* Copyright (c) 2002-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 interface for HotSpot services.

*

*/

// INCLUDES

#include "hssinterface.h"

#include "hotspotclientserver.h"

#include "am_debug.h"

#include <s32mem.h>

#include <es_enum.h>

#include <commdb.h>

// CONSTS

const TUint32 KHssWlanUserSettings  = 1;

_LIT( KHssWlanDeviceSettings,        "WLANDeviceTable" );

_LIT( KHssWlanDeviceSettingsType,    "WlanDeviceSettingsType" );

_LIT( KHssBgScanInterval,            "WlanBgScanInterval" );

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

// RHssInterface::ActivateNotificationsL

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

//

EXPORT_C void RHssInterface::ActivateNotificationsL( MHssSrvNotifications& aCallback )

    {

    DEBUG( "RHssInterface::ActivateNotificationsL()" );

    if( iNotify != NULL )

        {

        iNotify->Activate( aCallback );

        }

    else

        {

        iNotify = CHssSrvNotifications::NewL( aCallback, *this );        

        }

    }

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

// RHssInterface::CancelNotifications

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

//

EXPORT_C void RHssInterface::CancelNotifications()

    {

    DEBUG( "RHssInterface::CancelNotifications()" );

    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();

        }

    }

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

// RHssInterface::Close

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

//

EXPORT_C void RHssInterface::Close()

    {

    DEBUG( "RHssInterface::Close()" );

    if ( iNotify != NULL )

        {

        delete iNotify;    

        }

    iNotify = NULL;

    RHandleBase::Close();

    DEBUG( "RHssInterface::Close() Done" );

    }

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

// RHssInterface::Connect

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

//

EXPORT_C TInt RHssInterface::Connect()

    {

    TInt error = StartServer();

    DEBUG1( "RHssInterface::Connect() StartServer: %d", error ); 

	iNotify = NULL;

    if ( KErrNone == error )

        {

        error = CreateSession( KHotSpotDataServerName,

                               Version(),

                               KDefaultMsgSlots );

         DEBUG1( "RHssInterface::Connect() CreateSession: %d", error );  

        }

    return error;

    }

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

// RHssInterface::GetScanResults

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

//

EXPORT_C TInt RHssInterface::GetScanResults( HssScanList& aResults )

    {

    DEBUG( "RHssInterface::GetScanResults(HssScanList&)" );

    TInt ret( KErrNone );

    CHssScanHandler* scanHandler( NULL );

    TRAP( ret, scanHandler = CHssScanHandler::NewL() );

    if (ret == KErrNone)

        {

        ret = scanHandler->ScanRequest( aResults );

        delete scanHandler;

        }

    return ret;

    }

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

// RHssInterface::Register

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

//

EXPORT_C TUint RHssInterface::Register (const TUid aUID,

                                        const TDesC& aIapName, 

                                        const TUint aWaitnote)

    {

    DEBUG( "RHssInterface::Register()" );

    TPckgBuf< TClientUid > uidPckg;

    uidPckg().SetUid( aUID );

    TPckgBuf< TIapName > iapPckg;

    iapPckg().SetIapName( aIapName );

    TIpcArgs args( &uidPckg, &iapPckg,  aWaitnote );

    iIapId = SendReceive( EHssRegister, args );

    return iIapId;

    }

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

// RHssInterface::UnRegister

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

//

EXPORT_C TInt RHssInterface::UnRegister (const TUint aIapID, 

                                         const TUint aNetworkId,

                                         const TUid aUID)

    {

    DEBUG( "RHssInterface::UnRegister()" );

    TRAPD( err, StopConnectionL( aIapID, aNetworkId ) );

    if ( err == KErrNone )

        {

        TPckgBuf< TClientUid > uidPckg;

        uidPckg().SetUid( aUID );

        TIpcArgs args( aIapID, &uidPckg );

        err =  SendReceive( EHssUnRegister, args );

        }

    return err;

    }

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

// RHssInterface::ChangeSettings

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

//

EXPORT_C TInt RHssInterface::ChangeSettings ( const TUint aIapID, 

                                              const THssIapSettings& aSettings )

    {

    DEBUG( "RHssInterface::ChangeSettings()" );

    TInt ret( KErrNone );

    CHssIapHandler* iapHandler( NULL );

    TRAP( ret, iapHandler = CHssIapHandler::NewL());

    if ( ret != KErrNone )

        {

        DEBUG1( "RHssInterface::ChangeSettings() leave1: %d", ret );

        }

    else

        {

        TRAPD( err, ret = iapHandler->ChangeSettingsL( aIapID, aSettings ) );

        if ( err != KErrNone )

            {

            DEBUG1( "RHssInterface::ChangeSettings() leave2: %d", err );

            ret = err;

            }

        if ( iapHandler != NULL )

            {

            delete iapHandler;

            }

        }

    return ret;

    }

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

// RHssInterface::Stop

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

//

EXPORT_C TInt RHssInterface::Stop ( const TUint aIapID )

    {

    DEBUG( "RHssInterface::Stop()" );

    TIpcArgs args( aIapID );

    TInt ret = Send( EHssStop, args );

    TUint32 netId;

    CHssIapHandler* iapHandler(NULL);

    TRAPD( err, iapHandler = CHssIapHandler::NewL() );

    if (err == KErrNone)

        {

        TRAP( err, iapHandler->GetNetworkIdL( aIapID, netId ) );

        delete iapHandler;

        if (err == KErrNone)

            {

            TRAP( err, StopConnectionL( aIapID, netId ) );

            // Possible error value is neglected?!

            }

        }    

    return ret;

    }

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

// RHssInterface::CancelStart

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

//

EXPORT_C TInt RHssInterface::CancelStart ( const TUint aIapID )

    {

    DEBUG( "RHssInterface::CancelStart()" );

    TIpcArgs args( aIapID );

    return Send( EHssCancelStart, args );

    }

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

// RHssInterface::LoginComplete

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

//

EXPORT_C TInt RHssInterface::LoginComplete ( const TUint aIapID, const TInt aStatus )

    {

    DEBUG( "RHssInterface::LoginComplete()" );

    iArgs = TIpcArgs( aIapID, aStatus );

    return Send( EHssLoginComplete, iArgs );

    }

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

// RHssInterface::LogoutComplete

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

//

EXPORT_C TInt RHssInterface::LogoutComplete ( const TUint aIapID )

    {

    DEBUG( "RHssInterface::LogoutComplete()" );

    TIpcArgs args( aIapID );

    return Send( EHssLogoutComplete, args );

    }

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

// RHssInterface::Join

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

//

EXPORT_C TInt RHssInterface::Join( const TUint aIapId )

    {

    DEBUG( "RHssInterface::Join()" );

    TIpcArgs args( aIapId );

    return Send( EHssJoin, args );

    }

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

// RHssInterface::StartLogin

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

//

EXPORT_C void RHssInterface::StartLogin( const TUint aIapId, 

                                         const TUint aNetworkId,

                                         TRequestStatus& aStatus )

    {

    DEBUG( "RHssInterface::StartLogin()" );

    iArgs = TIpcArgs( aIapId, aNetworkId );

    SendReceive( EHssStartLogin, iArgs, aStatus );

    }

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

// RHssInterface::CancelLogin

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

//

EXPORT_C TInt RHssInterface::CancelLogin()

    {

    DEBUG( "RHssInterface::CancelLogin()" );

    return Send( EHssCancelLogin );

    }  

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

// RHssInterface::Start

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

//

EXPORT_C void RHssInterface::Start( const TUint aIapId, 

                                    TRequestStatus& aStatus )

    {

    DEBUG( "RHssInterface::Start()" );

    iArgs = TIpcArgs( aIapId );

    SendReceive( EHssStart, iArgs, aStatus );

    }

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

// RHssInterface::StartAgain

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

//

EXPORT_C void RHssInterface::StartAgain( const TUint aIapId, 

                                         TRequestStatus& aStatus )

    {

    DEBUG( "RHssInterface::StartAgain()" );

    iArgs = TIpcArgs( aIapId );

    SendReceive( EHssStartAgain, iArgs, aStatus );

    }

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

// RHssInterface::CloseConnection

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

//

EXPORT_C void RHssInterface::CloseConnection( const TUint aIapId,

                                              TRequestStatus& aStatus )

    {

    DEBUG( "RHssInterface::CloseConnection()" );

    iArgs = TIpcArgs( aIapId );

    SendReceive( EHssCloseConnection, iArgs, aStatus );

    }    

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

// RHssInterface::Cancel

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

//

EXPORT_C void RHssInterface::Cancel( const TUint aIapId )

    {

    DEBUG( "RHssInterface::Cancel()" );

    TIpcArgs args( aIapId );

    Send( EHssCancel, args );

    }

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

// RHssInterface::ShutdownServerL

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

//

EXPORT_C TInt RHssInterface::ShutdownServerL()

    {

    DEBUG( "RHssInterface::ShutdownServerL" );

    TInt ret( KErrNone );

    TInt iapId;

    TInt netId;

    TPckgBuf<TInt> iapPckg;

    TPckgBuf<TInt> netPckg;

    TIpcArgs args( &iapPckg, &netPckg );

    ret = SendReceive( EHssServerShutdown, args );

    if ( ret == KErrInUse )

        {

        iapId = iapPckg();

        netId = netPckg();

        DEBUG1("iapID RHSSINTERFACE : %d", iapId );

        ret = StopConnectionL( iapId, netId );

        if ( ret == KErrNone )

            {

            ret =  SendReceive( EHssServerShutdown, args );

            }

        }

    TIpcArgs args2( KHssShutdown ); 

    ret =  SendReceive( EHssServerShutdown, args2 );

    return ret;

    }

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

// RHssInterface::SetUiState

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

//

EXPORT_C void RHssInterface::SetUiState( const TUint aIapId,

                                         const TUint aState )

    {

    DEBUG( "RHssInterface::SetUiState()" );

    TIpcArgs args( aIapId, aState );

    SendReceive( EHssUiState, args );	

	}

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

// RHssInterface::Version

// Needed only when activating the server.

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

//

TVersion RHssInterface::Version() const

    {

    return( TVersion(

            KHotSpotMajorVersionNumber,

            KHotSpotMinorVersionNumber,

            KHotSpotBuildVersionNumber ) );

    }

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

// RHssInterface::StartServer()

// Starts the server if it is not already running

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

//

TInt RHssInterface::StartServer()

    {

    DEBUG( "RHssInterface::StartServer" );

    TInt result;

    TFindServer findHotSpotServer( KHotSpotDataServerName );

    TFullName name;

    result = findHotSpotServer.Next( name );

    if ( result == KErrNone )

        {

        // Server already running

        return KErrNone;

        }

    RSemaphore semaphore;

    result = semaphore.CreateGlobal( KHotSpotServerSemaphore, 0 );

    DEBUG1( "RHssInterface::StartServer semaphore: %d", result );

    if ( result != KErrNone )

        {

        return  result;

        }

    result = CreateServerProcess();

    DEBUG1( "RHssInterface::StartServer CreateServerProcess: %d", result );

    if ( result != KErrNone )

        {

        // Should the semaphore be closed if process creating fails?

        return  result;

        }

    semaphore.Wait();

    semaphore.Close();

    return KErrNone;

    }

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

// RHssInterface::CreateServerProcess()

// Creates a server process

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

//

TInt RHssInterface::CreateServerProcess()

    {

  	const TUidType serverUid( KNullUid,KNullUid, KHotspotServerUid3 );

	RProcess server;

	TInt r = server.Create(KHotSpotServerExe,KNullDesC);

	if ( r != KErrNone )

		{

	    DEBUG1( "**** RHssInterface: server start failed %d", r );

		return r;

		}

	TRequestStatus stat;

	server.Rendezvous( stat );

	if ( stat!=KRequestPending )

	    {

	    server.Kill(0);		// abort startup

	    }

    else

        {

        server.Resume();	// logon OK - start the server

        }

    DEBUG("**** RHssInterface: Started");

	User::WaitForRequest(stat);

	r = ( server.ExitType()==EExitPanic ) ? KErrGeneral : stat.Int();

	server.Close();

	return r;

    }

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

// RHssInterface::WaitForNotification

// When the message is completed at the server side, the

// CHssSrvNotifications::RunL() is been called. This is used by the

// notification service.

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

//

void RHssInterface::WaitForNotification(

    TRequestStatus& aReturnValue, 

    TDes8& aReturnData )

    {

    DEBUG( "RHssInterface::WaitForNotification()" );

    TIpcArgs params( &aReturnData );

    SendReceive( EHssActivateNotifications, params, aReturnValue );

    }

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

// RHssInterface::CancelWaitForNotification

// CHssSrvNotifications class uses this method to cancel pending 

// message at server side.

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

//

void RHssInterface::CancelWaitForNotification()

    {

    DEBUG( "RHssInterface::CancelWaitForNotification()" );

    // Check is notify service activated.

    if( iNotify != NULL )

        {

        // Send synchronous request to the data server

        DEBUG( "RHssInterface::CancelWaitForNotification() Cancelling..." );

        Send( EHssCancelNotifications, TIpcArgs() );

        DEBUG( "Done!" );

        }

    else

        {

        DEBUG( "RHssInterface::CancelWaitForNotification() Notification service was not started." );

        }

    }

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

// RHssInterface::StopConnectionL

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