/*
* 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
// ---------------------------------------------------------
//
TInt RHssInterface::StopConnectionL( const TUint aIapId, const TUint aNetworkId )
{
DEBUG( "RHssInterface::StopConnectionL()" );
TInt ret( KErrNone );
RSocketServ socketServ;
RConnection conn;
User::LeaveIfError( socketServ.Connect() );
CleanupClosePushL( socketServ );
// Open connection
User::LeaveIfError( conn.Open(socketServ) );
CleanupClosePushL( conn );
TConnectionInfo info;
info.iIapId = aIapId;
info.iNetId = aNetworkId;
TInt err = conn.Attach(
TPckg< TConnectionInfo >( info ),
RConnection::EAttachTypeNormal );
DEBUG1( "RHssInterface::conn.Attach: %d", err );
if ( err == KErrNone )
{
ret = conn.Stop( RConnection::EStopAuthoritative );
DEBUG1( "RHssInterface::connection.Stop: %d", ret );
}
/* Note: In previous version, tried to PopAndDestroy conn (RConnection)
* from cleanup stack...
* => Somehow this broke Sniffer connection opening, no idea why.
*/
CleanupStack::Pop( &conn );
conn.Close();
CleanupStack::PopAndDestroy( &socketServ );
return ret;
}
// ---------------------------------------------------------
// RHssInterface::CheckBackgroundScanL
// ---------------------------------------------------------
//
EXPORT_C TUint32 RHssInterface::CheckBackgroundScanL()
{
DEBUG( "RHssInterface::CheckBackgroundScanL()" );
CCommsDatabase* commDB = NULL;
CCommsDbTableView* table = NULL;
// Open commDB
commDB = CCommsDatabase::NewL();
CleanupStack::PushL( commDB );
table = commDB->OpenViewMatchingUintLC( KHssWlanDeviceSettings,
KHssWlanDeviceSettingsType,
KHssWlanUserSettings );
TInt err = table->GotoFirstRecord();
if ( err )
{
User::Leave( err );
}
TUint32 scanInterval;
table->ReadUintL( KHssBgScanInterval, scanInterval );
// cleanup
CleanupStack::PopAndDestroy( table );
CleanupStack::PopAndDestroy( commDB );
return (scanInterval);
}
// ---------------------------------------------------------
// RHssInterface::GetIap
// ---------------------------------------------------------
//
EXPORT_C TUint32 RHssInterface::GetIap( TIpcArgs aArgs )
{
DEBUG( "RHssInterface::GetIap()" );
return SendReceive ( EHssGetIAP, aArgs );
}
// ---------------------------------------------------------
// RHssInterface::StartBrowser
// ---------------------------------------------------------
//
EXPORT_C void RHssInterface::StartBrowser( const TDesC& aString,
const TUint aIapId,
const TUint aNetId,
TRequestStatus& aStatus )
{
DEBUG( "RHssInterface::StartBrowser()" );
iArgs = TIpcArgs( &aString, aIapId, aNetId ) ;
SendReceive( EHssStartBrowser, iArgs, aStatus );
}
// ---------------------------------------------------------
// RHssInterface::GetConnectionBssid
// ---------------------------------------------------------
//
EXPORT_C TInt RHssInterface::GetConnectionBssid( THssBssid& aBssId )
{
DEBUG( "RHssInterface::GetConnectionBssid()" );
TInt ret( KErrNone );
CHssScanHandler* scanHandler( NULL );
TRAP( ret, scanHandler = CHssScanHandler::NewL() );
if (KErrNone != ret )
{
DEBUG1( "RHssInterface::GetConnectionBssid() err:", ret );
}
else
{
ret = scanHandler->GetConnectionBssid( aBssId );
DEBUG1( "RHssInterface::GetConnectionBssid() ret:", ret );
delete scanHandler;
}
return ret;
}
// ---------------------------------------------------------
// RHssInterface::AddIapSsidList
// ---------------------------------------------------------
//
EXPORT_C TInt RHssInterface::AddIapSsidList(
TUint aIapId,
const CArrayFixFlat<THssSsid>& aSsidList )
{
DEBUG( "RHssInterface::AddIapSsidList()" );
TInt ret( KErrNone );
CHssScanHandler* scanHandler( NULL );
TRAP( ret, scanHandler = CHssScanHandler::NewL() );
if (KErrNone != ret )
{
DEBUG1( "RHssInterface::AddIapSsidList() err:", ret );
}
else
{
ret = scanHandler->AddIapSsidList( aIapId, aSsidList );
DEBUG1( "RHssInterface::AddIapSsidList() ret:", ret );
delete scanHandler;
}
return ret;
}
// -----------------------------------------------------------------------------
// RHssInterface::SetTimerValues
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RHssInterface::SetTimerValues (
TUid aClientUid,
TUint aLoginTimerValue,
TUint aLogoutTimerValue )
{
DEBUG( "RHssInterface::SetTimerValues()" );
TIpcArgs args( aClientUid.iUid, aLoginTimerValue, aLogoutTimerValue );
return Send( EHssSetTimerValues, args );
}
// ---------------------------------------------------------
// RHssInterface::GetClientIapsL
// ---------------------------------------------------------
//
EXPORT_C void RHssInterface::GetClientIapsL( const TUid aUid, RArray<TUint>& aIapIdArray )
{
DEBUG( "RHssInterface::GetClientIapsL()" );
CHssIapHandler* iapHandler( NULL );
iapHandler = CHssIapHandler::NewL();
CleanupStack::PushL( iapHandler );
iapHandler->GetClientIapsL( aUid, aIapIdArray );
CleanupStack::PopAndDestroy( iapHandler );
}
// End of File