diff -r b852595f5cbe -r 63be7eb3fc78 wlanutilities/wlansniffer/wlansnifferapplication/src/wlansnifferengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlanutilities/wlansniffer/wlansnifferapplication/src/wlansnifferengine.cpp Tue Aug 31 16:18:40 2010 +0300 @@ -0,0 +1,452 @@ +/* +* Copyright (c) 2009-2010 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 Sniffer application engine. +*/ + +// System includes + +#include + +#include +#include +#include +#include + +// User includes + +#include "wlanqtutils.h" +#include "wlansnifferservice.h" +#include "wlansnifferengine.h" + +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "wlansnifferengineTraces.h" +#endif + +/*! + \class WlanSnifferEngine + \brief WLAN Sniffer application engine. + + This class implements the WLAN Sniffer application engine. + The purpose of the engine implementation is to gather all non-UI + implementation base functionality into one place that can be utilized + from multiple places (i.e. multiple views and windows). +*/ + + +// External function prototypes + +// Local constants + +//! Master WLAN ON/OFF setting key +static const XQSettingsKey masterWlanKey( + XQSettingsKey::TargetCentralRepository, + KCRUidWlanDeviceSettingsRegistryId.iUid, + KWlanOnOff); + +//! WLAN forced OFF setting key +static const XQSettingsKey wlanForceKey( + XQSettingsKey::TargetCentralRepository, + KCRUidWlanDeviceSettingsRegistryId.iUid, + KWlanForceDisable); + +//! Offline mode setting key +static const XQSettingsKey offlineKey( + XQSettingsKey::TargetPublishAndSubscribe, + KPSUidStartup.iUid, + KPSGlobalSystemState); + +// ======== LOCAL FUNCTIONS ======== + +// ======== MEMBER FUNCTIONS ======== + +/*! + Constructor. + + @param [in] parent Parent object. + */ + +WlanSnifferEngine::WlanSnifferEngine(QObject *parent) : + QObject(parent), + mService(new WlanSnifferService(this)), + mSettingsManager(new XQSettingsManager(this)), + mScanTimerId(0), + mScanEnabled(false), + mEmbedded(false), + mWlanQtUtils(new WlanQtUtils()) +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_WLANSNIFFERENGINE_ENTRY); + + // Subscribe for WLAN status change indications + bool connectStatus = connect( + mSettingsManager, + SIGNAL(valueChanged(XQSettingsKey, QVariant)), + this, + SLOT(updateSetting(XQSettingsKey, QVariant))); + Q_ASSERT(connectStatus); + mSettingsManager->startMonitoring(masterWlanKey); + mSettingsManager->startMonitoring(wlanForceKey); + + // Connect WLAN Sniffer service signals + connectStatus = connect( + mService, + SIGNAL(toListView(QString)), + this, + SIGNAL(toListView(QString))); + Q_ASSERT(connectStatus == true); + connectStatus = connect( + mService, + SIGNAL(returnValueDelivered()), + this, + SIGNAL(exitTriggered())); + Q_ASSERT(connectStatus == true); + + // Store WLAN Sniffer service embedded status + mEmbedded = XQServiceUtil::isEmbedded(); + + OstTraceFunctionExit0(WLANSNIFFERENGINE_WLANSNIFFERENGINE_EXIT); +} + +/*! + Destructor. + */ + +WlanSnifferEngine::~WlanSnifferEngine() +{ + OstTraceFunctionEntry0(DUP1_WLANSNIFFERENGINE_WLANSNIFFERENGINE_ENTRY); + OstTraceFunctionExit0(DUP1_WLANSNIFFERENGINE_WLANSNIFFERENGINE_EXIT); +} + +/*! + Getter function for WLAN Qt Utilities instance owned by + this class. The whole WLAN Sniffer application uses the same + instance, and thus the reference is needed also in other classes. + + @return WLAN Qt Utilities object. + */ + +WlanQtUtils *WlanSnifferEngine::wlanQtUtils() const +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_WLANQTUTILS_ENTRY); + + // The reference must never be null. + Q_ASSERT(mWlanQtUtils.data()); + + OstTraceFunctionExit0(WLANSNIFFERENGINE_WLANQTUTILS_EXIT); + return mWlanQtUtils.data(); +} + +/*! + Getter for WLAN Sniffer service embedded property. + + @return TRUE if WLAN Sniffer is used as an embedded service. + */ + +bool WlanSnifferEngine::isEmbedded() const +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_ISEMBEDDED_ENTRY); + OstTraceFunctionExit0(WLANSNIFFERENGINE_ISEMBEDDED_EXIT); + return mEmbedded; +} + +/*! + Starts periodic WLAN Scanning. + It is allowed to call this function also when the scanning is already ON. + If so, the timer is not restarted but the scan period stays untouched. + */ + +void WlanSnifferEngine::startWlanScanning() +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_STARTWLANSCANNING_ENTRY); + + if (!mScanEnabled) { + OstTrace0( + TRACE_NORMAL, + WLANSNIFFERENGINE_STARTWLANSCANNING, + "WlanSnifferEngine::startWlanScanning Periodic WLAN scanning starting"); + + mScanEnabled = true; + // Connect response signal + bool connectStatus = connect( + mWlanQtUtils.data(), + SIGNAL(wlanScanReady(int)), + this, + SLOT(handleWlanScanReady(int))); + Q_ASSERT(connectStatus); + + // Start the first scan. Scan timer is started when scan result + // signal is received. + mWlanQtUtils->scanWlans(); + } + + OstTraceFunctionExit0(WLANSNIFFERENGINE_STARTWLANSCANNING_EXIT); +} + +/*! + Stops periodic WLAN Scanning. + It is allowed to call this function also when periodic scanning is OFF. + */ + +void WlanSnifferEngine::stopWlanScanning() +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_STOPWLANSCANNING_ENTRY); + + if (mScanEnabled) { + OstTrace0( + TRACE_NORMAL, + WLANSNIFFERENGINE_STOPWLANSCANNING, + "WlanSnifferEngine::stopWlanScanning Periodic WLAN scanning stopped"); + + mScanEnabled = false; + // Disconnect response signal + disconnect( + mWlanQtUtils.data(), + SIGNAL(wlanScanReady(int)), + this, + SLOT(handleWlanScanReady(int))); + + // Stop the scan + mWlanQtUtils->stopWlanScan(); + + // Stop periodic scan timer + if (mScanTimerId != 0) { + killTimer(mScanTimerId); + mScanTimerId = 0; + } + } + + OstTraceFunctionExit0(WLANSNIFFERENGINE_STOPWLANSCANNING_EXIT); +} + +/*! + Function for getting the master WLAN status. + + @return Master WLAN status: true if enabled, otherwise false. +*/ + +bool WlanSnifferEngine::masterWlan() const +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_MASTERWLAN_ENTRY, this); + + // Read WLAN ON/OFF setting from Cenrep + int wlanEnabled = mSettingsManager->readItemValue(masterWlanKey).toInt(); + + OstTrace1( + TRACE_NORMAL, + WLANSNIFFERENGINE_MASTERWLAN, + "WlanSnifferEngine::masterWlan;enabled=%d", + wlanEnabled); + + OstTraceFunctionExit1(WLANSNIFFERENGINE_MASTERWLAN_EXIT, this); + return wlanEnabled ? true : false; +} + +/*! + Function for switching the master WLAN status ON or OFF. + + @param [in] enabled If set to true, WLAN is switched ON, and vice versa. +*/ + +void WlanSnifferEngine::setMasterWlan(bool enabled) +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_SETMASTERWLAN_ENTRY, this); + + OstTraceExt1( + TRACE_NORMAL, + WLANSNIFFERENGINE_SETMASTERWLAN, + "WlanSnifferEngine::setMasterWlan;enabled=%hhu", + enabled); + + // Store WLAN ON/OFF setting to Cenrep + int wlanEnabled = enabled ? 1 : 0; + bool writeStatus = mSettingsManager->writeItemValue(masterWlanKey, wlanEnabled); + Q_ASSERT(writeStatus); + + OstTraceFunctionExit1(WLANSNIFFERENGINE_SETMASTERWLAN_EXIT, this); +} + +/*! + Function for getting the force disable WLAN status. + + @return forced WLAN status: true if disabled, otherwise false. +*/ + +bool WlanSnifferEngine::forceDisableWlan() const +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_FORCEDISABLEWLAN_ENTRY, this); + + // Read force disable WLAN ON/OFF setting from Cenrep + int wlanDisabled = mSettingsManager->readItemValue(wlanForceKey).toInt(); + + OstTrace1( + TRACE_NORMAL, + WLANSNIFFERENGINE_FORCEDISABLEWLAN, + "WlanSnifferEngine::forceDisableWlan;wlanDisabled=%d", + wlanDisabled); + + OstTraceFunctionEntry1(WLANSNIFFERENGINE_FORCEDISABLEWLAN_EXIT, this); + return wlanDisabled ? true : false; +} + +/*! + Function for getting the offline mode status. + + @return Offline mode status: true if offline, otherwise false. +*/ + +bool WlanSnifferEngine::offlineMode() const +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_OFFLINEMODE_ENTRY, this); + + // Read offline mode setting from Cenrep + int systemState = mSettingsManager->readItemValue(offlineKey).toInt(); + + bool offline = false; + if (ESwStateNormalRfOff == systemState) { + offline = true; + } + + OstTraceExt1( + TRACE_NORMAL, + WLANSNIFFERENGINE_OFFLINEMODE, + "WlanSnifferEngine::offlineMode;offline=%hhu", + offline); + + OstTraceFunctionExit1(WLANSNIFFERENGINE_OFFLINEMODE_EXIT, this); + return offline; +} + +/*! + Function for completing the running WLAN Sniffer service. + This function must only be ran if a WLAN Sniffer service is running. + */ + +void WlanSnifferEngine::completeService() +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_COMPLETESERVICE_ENTRY); + + mService->complete(); + + OstTraceFunctionExit0(WLANSNIFFERENGINE_COMPLETESERVICE_EXIT); +} + +/*! + This function (from QObject) handles timers. Initiates a new WLAN scan. + + @param [in] event Timer event. + */ + +void WlanSnifferEngine::timerEvent(QTimerEvent *event) +{ + OstTraceFunctionEntry0(WLANSNIFFERENGINE_TIMEREVENT_ENTRY); + + int timerId = event->timerId(); + + OstTrace1( + TRACE_NORMAL, + WLANSNIFFERENGINE_TIMEREVENT, + "WlanSnifferEngine::timerEvent;timerId=%d", + timerId); + + // WLAN scan timer is the only used timer + Q_ASSERT(timerId == mScanTimerId); + + // Request a new scan. Timer events come periodically. + mWlanQtUtils->scanWlans(); + + OstTraceFunctionExit0(WLANSNIFFERENGINE_TIMEREVENT_EXIT); +} + +/*! + Slot for updating settings. + + @param [in] key The changed key setting. + @param [in] value The new value of the setting. +*/ + +void WlanSnifferEngine::updateSetting( + const XQSettingsKey &key, + const QVariant &value) +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_UPDATESETTING_ENTRY, this); + + // Check that the key is WLAN ON/OFF, or wlanForceDisable since + // they are the only supported keys + Q_ASSERT( + key.target() == masterWlanKey.target() || + key.target() == wlanForceKey.target()); + Q_ASSERT( + key.uid() == masterWlanKey.uid() || + key.uid() == wlanForceKey.uid()); + Q_ASSERT( + key.key() == masterWlanKey.key() || + key.key() == wlanForceKey.key()); + + bool ok; + bool boolean = value.toInt(&ok) ? true : false; + Q_ASSERT(ok); + + // The updated key can be either the KWlanOnOff or the KWlanForceDisable + if (key.key() == wlanForceKey.key()) { + // Inform about WlanForceDisable status change + OstTraceExt1( + TRACE_NORMAL, + WLANSNIFFERENGINE_UPDATESETTING_WLANFORCEDISABLE, + "WlanSnifferEngine::emit forceWlanStatus;forcedWlanDisabled=%hhu", + boolean); + emit forceDisableWlanStatus(boolean); + } else { + // Inform about WLAN ON/OFF status change + OstTraceExt1( + TRACE_NORMAL, + WLANSNIFFERENGINE_UPDATESETTING_WLANONOFF, + "WlanSnifferEngine::emit masterWlanStatus;wlanEnabled=%hhu", + boolean); + emit masterWlanStatus(boolean); + } + + OstTraceFunctionExit1(WLANSNIFFERENGINE_UPDATESETTING_EXIT, this); +} + +/*! + Slot for handling Wlan scan result. + + @param [in] status Scan status code. +*/ + +void WlanSnifferEngine::handleWlanScanReady(int status) +{ + OstTraceFunctionEntry1(WLANSNIFFERENGINE_HANDLEWLANSCANREADY_ENTRY, this); + + OstTrace1( + TRACE_NORMAL, + WLANSNIFFERENGINE_HANDLEWLANSCANREADY, + "WlanSnifferEngine::handleWlanScanReady;status=%d", + status); + + // Forward result signal only, if there was no error + if (status == WlanQtUtils::ScanStatusOk) { + emit wlanScanReady(); + } + + // Start timer for the next scan, if not running already + if (mScanTimerId == 0) { + mScanTimerId = startTimer(scanTimerInterval); + // The timer start must succeed + Q_ASSERT(mScanTimerId != 0); + } + + OstTraceFunctionExit1(WLANSNIFFERENGINE_HANDLEWLANSCANREADY_EXIT, this); +}