diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanagent/src/wlanagtstates.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanagent/src/wlanagtstates.cpp Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,831 @@ +/* +* Copyright (c) 2002-2009 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: WLAN Agent state machine's state implementations +* +*/ + +/* +* %version: 35 % +*/ + +#include +#include +#include +#include +#include +#include +#include +#include "am_debug.h" +#include "genscanlist.h" +#include "genscaninfo.h" +#include "wlanagtstates.h" +#include "wlanagtsm.h" +#include "wlanagthotspotclient.inl" + +static const TUint KConnectionEndWaitTime = 2*1000000; // 2 seconds + +// ----------------------------------------------------------------------------- +// CWlanStateBase::CWlanStateBase +// ----------------------------------------------------------------------------- +// +CWlanStateBase::CWlanStateBase( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) : + CAgentStateBase( *aWlanSM ), + iWlanSM( aWlanSM ), + iWLMServer( aWLMServer ) + { + } + +// ----------------------------------------------------------------------------- +// CWlanStateBase::StartState +// ----------------------------------------------------------------------------- +// +void CWlanStateBase::StartState() + { + JumpToRunl( KErrNone ); + } + +// Default implementations for the functions from MWLMNotify don't do anything. +// If a state is interested in the notifications, it should 'activate' notifications +// and override these. + +// ----------------------------------------------------------------------------- +// CWlanStateBase::ConnectionStateChanged +// ----------------------------------------------------------------------------- +// +void CWlanStateBase::ConnectionStateChanged( TWlanConnectionState /* aNewState */ ) + { + DEBUG( "CWlanStateBase::ConnectionStateChanged()" ); + } + +// ----------------------------------------------------------------------------- +// CWlanStartState::CWlanStartState +// ----------------------------------------------------------------------------- +// +CWlanStartState::CWlanStartState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) : + CWlanStateBase( aWlanSM, aWLMServer ), + iNextState( EWlanAgtNextStateUnknown ) + { + DEBUG( "CWlanStartState constructor" ); + } + +// ----------------------------------------------------------------------------- +// CWlanStartState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanStartState::RunL() + { + if( iWlanSM->WlanSettings()->SSID.Length() == 0 ) + { + PrepareEasyWlanParamsL(); + } + + DEBUG( "CWlanStartState: next state: EWlanAgtNextStateJoin" ); + iNextState = EWlanAgtNextStateJoin; + + iWlanSM->CompleteState( KErrNone ); + } + + +// ----------------------------------------------------------------------------- +// CWlanStartState::PrepareEasyWlanParamsL +// ----------------------------------------------------------------------------- +// +void CWlanStartState::PrepareEasyWlanParamsL() + { + DEBUG( "CWlanStartState::PrepareEasyWlanParamsL()" ); + TPckgBuf iWep; + TPtr8 wepPtr( &iWep().KeyMaterial[0], KWLMMaxWEPKeyLength ); + TPckgBuf iPsk; + TPtr8 pskPtr( &iPsk().KeyMaterial[0], KWLMMaxWpaPskLength ); + TWLMOverrideSettings overrides; + Mem::FillZ(&overrides, sizeof(overrides)); + + TBuf8 ssid8; + CnvUtfConverter::ConvertFromUnicodeToUtf8( ssid8, iWlanSM->WlanSettings()->UsedSSID ); + + overrides.settingsMask = EOverrideSsidMask; + overrides.ssid.ssidLength = ssid8.Length(); + Mem::Copy(overrides.ssid.ssid, ssid8.Ptr(), overrides.ssid.ssidLength); + + if ( (iWlanSM->WlanSettings())->ConnectionMode == Adhoc ) + { + DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), conn mode: Adhoc" ); + overrides.settingsMask |= EOverrideIbssMask; + } + + // Set security mode and parameters + switch( iWlanSM->WlanSettings()->SecurityMode ) + { + case AllowUnsecure: + DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Open" ); + break; + case Wep: + DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wep" ); + overrides.settingsMask |= EOverrideWepMask; + + Mem::Copy(&iWep().KeyMaterial[0], &((iWlanSM->WlanSettings()->WepKey1).KeyMaterial[0]), (iWlanSM->WlanSettings()->WepKey1).KeyLength); + iWep().KeyIndex = (iWlanSM->WlanSettings()->WepKey1).KeyIndex; + iWep().KeyLength = (iWlanSM->WlanSettings()->WepKey1).KeyLength; + + overrides.wep = iWep(); + break; + case Wlan8021x: + case Wpa: + case Wpa2Only: + if ( iWlanSM->WlanSettings()->EnableWpaPsk ) + { + DEBUG1( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wpa-psk,len:%d", + iWlanSM->WlanSettings()->WPAKeyLength ); + + overrides.settingsMask |= EOverrideWpaPskMask; + pskPtr.Copy( iWlanSM->WlanSettings()->WPAPreSharedKey ); + iPsk().KeyLength = iWlanSM->WlanSettings()->WPAKeyLength; + + overrides.wpaPsk = iPsk(); + } + else + { + DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wpa" ); + overrides.settingsMask |= EOverrideWpaMask; + } + break; + default: + DEBUG1( "CWlanStartState::PrepareEasyWlanParamsL(), wrong security mode value in commsdat:%d", + iWlanSM->WlanSettings()->SecurityMode ); + User::LeaveIfError(KErrGeneral); + return; + } + + iWlanSM->SetOverrideSettingsL( overrides ); + } + + +// ----------------------------------------------------------------------------- +// CWlanStartState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanStartState::NextStateL(TBool aContinue) + { + DEBUG( "CWlanStartState::NextStateL()" ); + + if( aContinue ) + { + switch(iNextState) + { + case EWlanAgtNextStateJoin: + return new (ELeave) CWlanJoinState(iWlanSM, iWLMServer); + case EWlanAgtNextStateOpen: + return new (ELeave) CWlanOpenState(iWlanSM, iWLMServer); + default: + return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect ); + } + } + else + { + return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect ); + } + } + +// ----------------------------------------------------------------------------- +// CWlanStartState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanStartState::DoCancel() + { + } + + +// ----------------------------------------------------------------------------- +// CWlanJoinState::CWlanJoinState +// ----------------------------------------------------------------------------- +// +CWlanJoinState::CWlanJoinState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) : + CWlanStateBase( aWlanSM, aWLMServer ) + { + DEBUG( "CWlanJoinState constructor" ); + } + +// ----------------------------------------------------------------------------- +// CWlanJoinState::~CWlanJoinState +// ----------------------------------------------------------------------------- +// +CWlanJoinState::~CWlanJoinState() + { + DEBUG( "CWlanJoinState destructor" ); + Cancel(); + if ( iAgtHotSpotClient ) + { + delete iAgtHotSpotClient; + } + } + +// ----------------------------------------------------------------------------- +// CWlanJoinState::StartState +// ----------------------------------------------------------------------------- +// +void CWlanJoinState::StartState() + { + DEBUG( "CWlanJoinState::StartState()" ); + TRAPD( ret, DoStartStateL() ); + if( ret != KErrNone ) + { + iContext = EHotSpotFailure; + JumpToRunl( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CWlanJoinState::DoStartStateL +// ----------------------------------------------------------------------------- +// +void CWlanJoinState::DoStartStateL() + { + DEBUG( "CWlanJoinState::DoStartStateL()" ); + + // check if plug-in is available + TRAPD( ret, iAgtHotSpotClient = CWlanAgtHotSpotClient::NewL() ); + + if ( ret == KErrNone ) + { + DEBUG( "CWlanJoinState::DoStartStateL(), AgtHotSpot plugin available" ); + + //Assume that AP is HotSpot AP. Later if HS Server says its not HS AP, then it will be set as normal AP + iWlanSM->SetHotSpotAP( ETrue ); + + // talk to hotspot server + DEBUG( "CWlanJoinState::DoStartStateL(), Sending Start message to HotSpot Server" ); + iAgtHotSpotClient->HotSpotStart( iWlanSM->IapId(), iStatus ); + iContext = EHotSpotInProgress; + SetActive(); + } + else + { + iAgtHotSpotClient = NULL; + DEBUG( "CWlanJoinState::DoStartStateL(), Couldn't find AgtHotSpot plug-in,defaulting to normal procedure" ); + + iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() ); + SetActive(); + } + } + +// ----------------------------------------------------------------------------- +// CWlanJoinState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanJoinState::NextStateL( TBool aContinue ) + { + DEBUG( "CWlanJoinState::NextStateL()" ); + + if( aContinue ) + { + return new (ELeave) CWlanOpenState( iWlanSM, iWLMServer ); + } + else if( iStatus.Int() == KErrWlanConnAlreadyActive ) + { + return new(ELeave) CWlanErrorState( iWlanSM, KErrWlanConnAlreadyActive ); + } + else + { + return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect ); + } + } + +// ----------------------------------------------------------------------------- +// CWlanJoinState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanJoinState::RunL() + { + DEBUG1( "CWlanJoinState::RunL(), iStatus = %i", iStatus.Int() ); + + if( iAgtHotSpotClient ) + { + switch( iContext ) + { + case EHotSpotInProgress: + if( iStatus != KErrNone ) + { + if( iStatus == KErrNotSupported ) + { + DEBUG( "CWlanJoinState::RunL(), HotSpot Server returned KErrNotSupported, treating it as normal AP" ); + iWlanSM->SetHotSpotAP( EFalse ); + iContext = EHotSpotNormalAP; + } + else + { + DEBUG( "CWlanJoinState::RunL(), Error returned by HotSpot Server" ); + iContext = EHotSpotFailure; + } + iAgtHotSpotClient->HotSpotCloseConnection( iWlanSM->IapId(), iStatus ); + SetActive(); + } + else + { + // send Join request to WLM server + DEBUG( "CWlanJoinState::RunL(), Sending Join request to Engine" ); + iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() ); + iContext = EHotSpotWLMServerHS; + SetActive(); + } + break; + + case EHotSpotWLMServerHS: + if(iStatus != KErrNone) + { + DEBUG( "CWlanJoinState::RunL(), Join failed, Continue trying with HOTSPOT Server" ); + iAgtHotSpotClient->HotSpotStartAgain( iWlanSM->IapId(), iStatus ); + iContext = EHotSpotInProgress; + SetActive(); + } + else + { + DEBUG( "CWlanJoinState::RunL(), Successfully joined to network, CloseConnection will be called from Disconnect State"); + DEBUG( "CWlanJoinState::RunL(), Sending ServiceStarted indication to NIFMAN" ); + iSMObserver->ServiceStarted(); + iWlanSM->CompleteState( KErrNone ); + } + break; + + case EHotSpotNormalAP: + // send Join request to WLM server + DEBUG( "CWlanJoinState::RunL(), Sending Join request to Engine" ); + iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() ); + iContext = EHotSpotWLMServerNormal; + SetActive(); + break; + + case EHotSpotWLMServerNormal: + if(iStatus != KErrNone) + { + DEBUG1( "CWlanJoinState::RunL(), Join failed(%d), not retrying with HotSpot Server, as this is normal AP", iStatus.Int() ); + iSMObserver->ConnectionComplete( EAttemptingToJoin, iStatus.Int() ); + } + else + { + DEBUG( "CWlanJoinState::RunL(), Successfully joined to network,Sending ServiceStarted indication to NIFMAN" ); + iSMObserver->ServiceStarted(); + iWlanSM->CompleteState( KErrNone ); + } + break; + + case EHotSpotFailure: + DEBUG( "CWlanJoinState::RunL(), Cancelling the Join operation" ); + iSMObserver->ConnectionComplete( EAttemptingToJoin, KErrCouldNotConnect ); + break; + + default: + DEBUG( "CWlanJoinState::RunL(), Unknown Active Object context, Panicing.." ); + User::Panic( _L("wlanagt"), KErrGeneral ); + break; + } + } + + else + { + //Normal AP + if(iStatus != KErrNone) + { + iSMObserver->ConnectionComplete( EAttemptingToJoin, iStatus.Int() ); + return; + } + else + { + DEBUG( "CWlanJoinState::RunL(), Successfully joined to network" ); + + // Nifman loads the NIF after a ServiceStarted() call + iSMObserver->ServiceStarted(); + iWlanSM->CompleteState( KErrNone ); + } + } + + } + +// CWlanJoinState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanJoinState::DoCancel() + { + DEBUG( "CWlanJoinState::DoCancel()" ); + if ( iAgtHotSpotClient ) + { + //Cancel is sent to HSS even if there is no pending request, so that CloseConnection is not + //required to be called seperately + DEBUG( "CWlanJoinState::DoCancel(), Sending Cancel to HotSpot Server" ); + iAgtHotSpotClient->HotSpotCancel( iWlanSM->IapId() ); + } + + // If Join request is sent to Engine, cancel it by sending Release request + if ( !(iAgtHotSpotClient) || iContext == EHotSpotWLMServerHS || + iContext == EHotSpotWLMServerNormal ) + { + DEBUG( "CWlanJoinState::DoCancel(), Sending Release to WLM Server" ); + iWLMServer.Release(); + } + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::CWlanOpenState +// ----------------------------------------------------------------------------- +// +CWlanOpenState::CWlanOpenState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) : + CWlanStateBase( aWlanSM, aWLMServer ), + iSubState( EWlanOpenSubStateOpening ) + { + DEBUG( "CWlanOpenState constructor" ); + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::StartState +// ----------------------------------------------------------------------------- +// +void CWlanOpenState::StartState() + { + DEBUG( "CWlanOpenState::StartState()" ); + TRAPD( ret, DoStartStateL() ); + JumpToRunl( ret ); + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::DoStartStateL +// ----------------------------------------------------------------------------- +// +void CWlanOpenState::DoStartStateL() + { + DEBUG( "CWlanOpenState::DoStartStateL()" ); + + // @to do: whether this callback system is needed anymore or not, + // should be checked. + + // Create a callback for handling the "disconnect" notification from + // WLM. We must use async callback to avoid deleting iNotify of RWLMServer + // "too early" (ConnectionStateChanged() notification call from WLM must + // not result to calling CancelNotifies() of RWLMServer synchronously). + TCallBack callback( DisconnectCb, this ); + iDisconnectCb = new (ELeave) CAsyncCallBack( callback, CActive::EPriorityStandard ); + + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanOpenState::NextStateL( TBool /*aContinue*/ ) + { + DEBUG( "CWlanOpenState::NextStateL(), calling RWLMServer::CancelNotifies()" ); + iWLMServer.CancelNotifies(); + return new (ELeave) CWlanDisconnectState( iWlanSM, iWLMServer ); + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanOpenState::RunL() + { + DEBUG( "CWlanOpenState::RunL()" ); + + switch( iSubState ) + { + case EWlanOpenSubStateOpening: + if( iStatus != KErrNone ) + { + iSMObserver->ConnectionComplete( EOpeningConnection, iStatus.Int() ); + return; + } + DEBUG( "CWlanOpenState::RunL(), Connection Complete with KErrNone" ); + iSMObserver->ConnectionComplete( KConnectionOpen, KErrNone ); + iSubState = EWlanOpenSubStateOpened; + + DEBUG( "CWlanOpenState::RunL(), calling RWLMServer::ActivateNotifiesL()" ); + iWLMServer.ActivateNotifiesL( *this, EWlmNotifyConnectionStateChanged ); + break; + case EWlanOpenSubStateOpened: + User::Panic( _L("wlanagt"), KErrGeneral ); + break; + default: + User::Panic( _L("wlanagt"), KErrGeneral ); + break; + } + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanOpenState::DoCancel() + { + DEBUG( "CWlanOpenState::DoCancel()" ); + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::DisconnectCb +// ----------------------------------------------------------------------------- +// +TInt CWlanOpenState::DisconnectCb( TAny* aThisPtr ) + { + DEBUG( "CCWlanOpenState::DisconnectCb()" ); + + CWlanOpenState* self = static_cast( aThisPtr ); + + // Send a "vendor specific" notification to wlannif. This is the only + // agent-to-nif notification we use, and always means that interface should + // be stopped. + self->iSMObserver->Notification( EAgentToNifEventVendorSpecific, NULL ); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::ConnectionStateChanged +// ----------------------------------------------------------------------------- +// +void CWlanOpenState::ConnectionStateChanged( TWlanConnectionState aNewState ) + { + DEBUG1( "CWlanOpenState::ConnectionStateChanged(), new state %i", aNewState ); + + // EWlanStateNotConnected is the only connection state we are interested in. + if( aNewState == EWlanStateNotConnected ) + { + DEBUG( "CWlanOpenState::ConnectionStateChanged(), calling iDisconnectCb->CallBack()" ); + + iDisconnectCb->CallBack(); + } + } + +// ----------------------------------------------------------------------------- +// CWlanOpenState::~CWlanOpenState +// ----------------------------------------------------------------------------- +// +CWlanOpenState::~CWlanOpenState() + { + DEBUG( "CWlanOpenState destructor" ); + delete iDisconnectCb; + } + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::CWlanDisconnectState +// ----------------------------------------------------------------------------- +// +CWlanDisconnectState::CWlanDisconnectState(CWlanSM* aWlanSM, RWLMServer& aWLMServer) : + CWlanStateBase(aWlanSM, aWLMServer) + { + DEBUG( "CWlanDisconnectState constructor" ); + } + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::~CWlanDisconnectState +// ----------------------------------------------------------------------------- +// +CWlanDisconnectState::~CWlanDisconnectState() + { + DEBUG( "CWlanDisconnectState destructor" ); + Cancel(); + if ( iAgtHotSpotClient ) + { + delete iAgtHotSpotClient; + } + } + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::StartState +// ----------------------------------------------------------------------------- +// +void CWlanDisconnectState::StartState() + { + DEBUG( "CWlanDisconnectState::StartState()" ); + // check if plug-in is available + TRAPD( ret, iAgtHotSpotClient = CWlanAgtHotSpotClient::NewL() ); + + if( ret == KErrNone ) + { + DEBUG( "CWlanDisconnectState::StartState(), AgtHotSpot plugin is available" ); + + if ( iWlanSM->IsHotSpotAP() ) + { + // talk to hospot server + DEBUG( "CWlanDisconnectState::StartState(), Sending CloseConnection message to HotSpot Server" ); + iAgtHotSpotClient->HotSpotCloseConnection( iWlanSM->IapId(), iStatus ); + SetActive(); + return; + } + } + else + { + iAgtHotSpotClient = NULL; + } + JumpToRunl( KErrNone ); + } + + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanDisconnectState::NextStateL( TBool /*aContinue*/ ) + { + DEBUG( "CWlanDisconnectState::NextStateL()" ); + return new (ELeave) CWlanDisconnectState( iWlanSM, iWLMServer ); + } + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanDisconnectState::RunL() + { + DEBUG( "CWlanDisconnectState::RunL()" ); + iSMObserver->UpdateProgress( EDisconnecting, KErrNone ); + DEBUG( "CWlanDisconnectState::RunL(), calling RWLMServer::Release()" ); + + // Only call iWLMServer.Release() and assume that disconnect is complete. + iWLMServer.Release(); + iSMObserver->DisconnectComplete(); + } + +// ----------------------------------------------------------------------------- +// CWlanDisconnectState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanDisconnectState::DoCancel() + { + DEBUG( "CWlanDisconnectState::DoCancel()" ); + if( iAgtHotSpotClient ) + { + iAgtHotSpotClient->HotSpotCancel( iWlanSM->IapId() ); + } + } + +// ----------------------------------------------------------------------------- +// CWlanErrorState::CWlanErrorState +// ----------------------------------------------------------------------------- +// +// CWlanErrorState +// +// "Dummy state" that only reports an error. +// Currently only used when the CWlanSM cannot be constructed properly. +// +CWlanErrorState::CWlanErrorState( CWlanSM* aWlanSM, TInt aError ) : + CAgentStateBase( *aWlanSM ), + iWlanSM( aWlanSM ), + iError( aError ) + { + DEBUG( "CWlanErrorState constructor" ); + } + +// ----------------------------------------------------------------------------- +// CWlanErrorState::StartState +// ----------------------------------------------------------------------------- +// +void CWlanErrorState::StartState() + { + DEBUG( "CWlanErrorState::StartState()" ); + JumpToRunl( KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CWlanErrorState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanErrorState::NextStateL( TBool /*aContinue*/ ) + { + DEBUG( "CWlanErrorState::NextStateL()" ); + return new (ELeave) CWlanErrorState( iWlanSM, iError ); + } + +// ----------------------------------------------------------------------------- +// CWlanErrorState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanErrorState::RunL() + { + DEBUG( "CWlanErrorState::RunL()" ); + iWlanSM->CompleteState( iError ); + } + +// ----------------------------------------------------------------------------- +// CWlanErrorState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanErrorState::DoCancel() + { + DEBUG( "CWlanErrorState::DoCancel" ); + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::CWlanWaitConnectionState +// ----------------------------------------------------------------------------- +// +CWlanWaitConnectionState::CWlanWaitConnectionState( + CWlanSM* aWlanSM, + RWLMServer& aWLMServer ) : + CWlanStateBase( aWlanSM, aWLMServer ) + { + DEBUG( "CWlanWaitConnectionState::CWlanWaitConnectionState()" ); + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::~CWlanWaitConnectionState +// ----------------------------------------------------------------------------- +// +CWlanWaitConnectionState::~CWlanWaitConnectionState() + { + DEBUG( "CWlanWaitConnectionState::~CWlanWaitConnectionState()" ); + iTimer.Close(); + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::StartState +// ----------------------------------------------------------------------------- +// +void CWlanWaitConnectionState::StartState() + { + DEBUG( "CWlanWaitConnectionState::StartState()" ); + + DEBUG1( "CWlanWaitConnectionState::StartState() - setting the timer to %u microseconds", + KConnectionEndWaitTime ); + + TInt ret = iTimer.CreateLocal(); + if ( ret != KErrNone ) + { + DEBUG1( "CWlanWaitConnectionState::StartState() - unable to create the timer (%d)", + ret ); + + JumpToRunl( ret ); + } + + iTimer.After( iStatus, KConnectionEndWaitTime ); + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::NextStateL +// ----------------------------------------------------------------------------- +// +CAgentStateBase* CWlanWaitConnectionState::NextStateL(TBool aContinue) + { + DEBUG( "CWlanWaitConnectionState::NextStateL()" ); + DEBUG1( "CWlanWaitConnectionState::NextStateL() - aContinue %u", + aContinue ); + + if( aContinue ) + { + return new (ELeave) CWlanStartState( iWlanSM, iWLMServer ); + } + + return new (ELeave) CWlanErrorState( iWlanSM, KErrWlanConnAlreadyActive ); + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::RunL +// ----------------------------------------------------------------------------- +// +void CWlanWaitConnectionState::RunL() + { + DEBUG( "CWlanWaitConnectionState::RunL()" ); + DEBUG1( "CWlanWaitConnectionState::RunL() - iStatus %d" , iStatus.Int() ); + + if ( iStatus.Int()!= KErrNone ) + { + iSMObserver->ConnectionComplete( EAttemptingToJoin, iStatus.Int() ); + } + else + { + TWlanConnectionState state = iWLMServer.GetConnectionState(); + + DEBUG1( "CWlanWaitConnectionState::RunL() - WLAN engine state is %u", + state ); + + if ( state != EWlanStateNotConnected ) + { + DEBUG( "CWlanWaitConnectionState::RunL() - connection is still open" ); + DEBUG( "CWlanWaitConnectionState::RunL() - completing request with KErrWlanConnAlreadyActive" ); + + iSMObserver->ConnectionComplete( EAttemptingToJoin, KErrWlanConnAlreadyActive ); + } + else + { + DEBUG( "CWlanWaitConnectionState::RunL() - connection has closed, continuing with request" ); + iWlanSM->CompleteState( KErrNone ); + } + } + } + +// ----------------------------------------------------------------------------- +// CWlanWaitConnectionState::DoCancel +// ----------------------------------------------------------------------------- +// +void CWlanWaitConnectionState::DoCancel() + { + DEBUG( "CWlanWaitConnectionState::DoCancel()" ); + iTimer.Cancel(); + }