MCL/sf/mw/qtextensions: comparison qtmobility/src/bearer/qnetworkconfigmanager_s60

equal deleted inserted replaced

-:cfcbf08528c4
+:5822d84012fb
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the Qt Mobility Components.
 **
 #include "qnetworkconfigmanager_s60_p.h"
 #include <commdb.h>
 #include <cdbcols.h>
 #include <d32dbms.h>
+#include <QEventLoop>
+#include <QTimer>
+#include <QTime>  // For randgen seeding
+#include <QtCore> // For randgen seeding
+// #define QT_BEARERMGMT_CONFIGMGR_DEBUG
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+#include <QDebug>
+#endif
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 #include <cmdestination.h>
 #include <cmconnectionmethod.h>
 #include <cmconnectionmethoddef.h>
 static const int KValueThatWillBeAddedToSNAPId = 1000;
 static const int KUserChoiceIAPId = 0;
 QNetworkConfigurationManagerPrivate::QNetworkConfigurationManagerPrivate()
-: QObject(0), CActive(CActive::EPriorityIdle), capFlags(0), iFirstUpdate(true), iInitOk(true)
+: QObject(0), CActive(CActive::EPriorityIdle), capFlags(0),
+iFirstUpdate(true), iInitOk(true), iIgnoringUpdates(false),
+iTimeToWait(0), iIgnoreEventLoop(0)
 {
 CActiveScheduler::Add(this);
+// Seed the randomgenerator
+qsrand(QTime(0,0,0).secsTo(QTime::currentTime()) + QCoreApplication::applicationPid());
+iIgnoreEventLoop = new QEventLoop(this);
 registerPlatformCapabilities();
 TRAPD(error, ipCommsDB = CCommsDatabase::NewL(EDatabaseTypeIAP));
 if (error != KErrNone) {
 iInitOk = false;
 cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
 cpPriv->roamingSupported = false;
 cpPriv->manager = this;
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv);
 userChoiceConfigurations.insert(cpPriv->id, ptr);
 updateConfigurations();
 updateStatesToSnaps();
 updateAvailableAccessPoints(); // On first time updates synchronously (without WLAN scans)
 // Start monitoring IAP and/or SNAP changes in Symbian CommsDB
 startCommsDatabaseNotifications();
 iFirstUpdate = false;
 }
 QNetworkConfigurationManagerPrivate::~QNetworkConfigurationManagerPrivate()
 {
 Cancel();
-QList<QString> configIdents = snapConfigurations.keys();
+foreach (const QString &oldIface, snapConfigurations.keys()) {
-foreach(QString oldIface, configIdents) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.take(oldIface);
 priv->isValid = false;
 priv->id.clear();
 }
-configIdents = accessPointConfigurations.keys();
+foreach (const QString &oldIface, accessPointConfigurations.keys()) {
-foreach(QString oldIface, configIdents) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.take(oldIface);
 priv->isValid = false;
 priv->id.clear();
 }
-configIdents = userChoiceConfigurations.keys();
+foreach (const QString &oldIface, userChoiceConfigurations.keys()) {
-foreach(QString oldIface, configIdents) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = userChoiceConfigurations.take(oldIface);
 priv->isValid = false;
 priv->id.clear();
 priv->manager = 0;
 }
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 capFlags |= QNetworkConfigurationManager::ApplicationLevelRoaming;
 capFlags |= QNetworkConfigurationManager::ForcedRoaming;
 #endif
 capFlags |= QNetworkConfigurationManager::DataStatistics;
+capFlags |= QNetworkConfigurationManager::NetworkSessionRequired;
 }
 void QNetworkConfigurationManagerPrivate::performAsyncConfigurationUpdate()
 {
 if (!iInitOk || iUpdateGoingOn) {
 void QNetworkConfigurationManagerPrivate::updateConfigurationsL()
 {
 QList<QString> knownConfigs = accessPointConfigurations.keys();
 QList<QString> knownSnapConfigs = snapConfigurations.keys();
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 // S60 version is >= Series60 3rd Edition Feature Pack 2
 TInt error = KErrNone;
 // Loop through all IAPs
 }
 CleanupStack::PopAndDestroy(pDbTView);
 #endif
 updateActiveAccessPoints();
-foreach (QString oldIface, knownConfigs) {
+foreach (const QString &oldIface, knownConfigs) {
 //remove non existing IAP
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.take(oldIface);
 priv->isValid = false;
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = priv;
 emit configurationRemoved(item);
 }
 // Remove non existing IAP from SNAPs
-QList<QString> snapConfigIdents = snapConfigurations.keys();
+foreach (const QString &iface, snapConfigurations.keys()) {
-foreach (QString iface, snapConfigIdents) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv2 = snapConfigurations.value(iface);
 // => Check if one of the IAPs of the SNAP is active
 for (int i=0; i<priv2->serviceNetworkMembers.count(); i++) {
 if (priv2->serviceNetworkMembers[i]->numericId == priv->numericId) {
 priv2->serviceNetworkMembers.removeAt(i);
 break;
 }
 }
 }
 }
-foreach (QString oldIface, knownSnapConfigs) {
+foreach (const QString &oldIface, knownSnapConfigs) {
 //remove non existing SNAPs
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.take(oldIface);
 priv->isValid = false;
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 }
 }
 }
 // Make sure that state of rest of the IAPs won't be Active
-foreach (QString iface, inactiveConfigs) {
+foreach (const QString &iface, inactiveConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()) {
 // Configuration is either Defined or Discovered
 changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Discovered);
 }
 }
 }
 }
 // Make sure that state of rest of the IAPs won't be Discovered or Active
-foreach (QString iface, unavailableConfigs) {
+foreach (const QString &iface, unavailableConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()) {
 // Configuration is Defined
 changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Defined);
 }
 }
 void QNetworkConfigurationManagerPrivate::updateStatesToSnaps()
 {
 // Go through SNAPs and set correct state to SNAPs
-QList<QString> snapConfigIdents = snapConfigurations.keys();
+foreach (const QString &iface, snapConfigurations.keys()) {
-foreach (QString iface, snapConfigIdents) {
 bool discovered = false;
 bool active = false;
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.value(iface);
 // => Check if one of the IAPs of the SNAP is discovered or active
 //    => If one of IAPs is active, also SNAP is active
 }
 }
 void QNetworkConfigurationManagerPrivate::RunL()
 {
+if (iIgnoringUpdates) {
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+qDebug("CommsDB event handling postponed (postpone-timer running because IAPs/SNAPs were updated very recently).");
+#endif
+return;
+}
 if (iStatus != KErrCancel) {
 RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
 switch (event) {
-//        case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
+case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
 case RDbNotifier::ECommit:   /** A transaction has been committed.  */
 case RDbNotifier::ERollback: /** A transaction has been rolled back */
 case RDbNotifier::ERecover:  /** The database has been recovered    */
-// Note that if further database events occur while a client is handling
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
-// a request completion, the notifier records the most significant database
+qDebug("CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
-// event and this is signalled as soon as the client issues the next
+#endif
-// RequestNotification() request.
+iIgnoringUpdates = true;
-// => Stop recording notifications
+// Other events than ECommit get lower priority. In practice with those events,
-stopCommsDatabaseNotifications();
+// we delay_before_updating methods, whereas
-TRAPD(error, updateConfigurationsL());
+// with ECommit we _update_before_delaying the reaction to next event.
-if (error == KErrNone) {
+// Few important notes: 1) listening to only ECommit does not seem to be adequate,
-updateStatesToSnaps();
+// but updates will be missed. Hence other events are reacted upon too.
-}
+// 2) RDbNotifier records the most significant event, and that will be returned once
+// we issue new RequestNotification, and hence updates will not be missed even
+// when we are 'not reacting to them' for few seconds.
+if (event == RDbNotifier::ECommit) {
+TRAPD(error, updateConfigurationsL());
+if (error == KErrNone) {
+updateStatesToSnaps();
+}
+waitRandomTime();
+} else {
+waitRandomTime();
+TRAPD(error, updateConfigurationsL());
+if (error == KErrNone) {
+updateStatesToSnaps();
+}
+}
+iIgnoringUpdates = false; // Wait time done, allow updating again
 iWaitingCommsDatabaseNotifications = true;
 break;
 default:
 // Do nothing
 break;
 }
 }
 if (iWaitingCommsDatabaseNotifications) {
 if (!IsActive()) {
 SetActive();
 // Start waiting for new notification
 ipCommsDB->RequestNotification(iStatus);
 updateStatesToSnaps();
 }
 }
 bool online = false;
-QList<QString> iapConfigs = accessPointConfigurations.keys();
+foreach (const QString &iface, accessPointConfigurations.keys()) {
-foreach (QString iface, iapConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()->state == QNetworkConfiguration::Active) {
 online = true;
 break;
 }
 // Configuration is either Discovered or Active
 changeConfigurationStateAtMinTo(priv, QNetworkConfiguration::Discovered);
 unDiscoveredConfigs.removeOne(ident);
 }
 }
-foreach (QString iface, unDiscoveredConfigs) {
+foreach (const QString &iface, unDiscoveredConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()) {
 // Configuration is Defined
 changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Defined);
 }
 default:
 // For unrecognized events
 break;
 }
+}
+// Waits for 1..4 seconds.
+void QNetworkConfigurationManagerPrivate::waitRandomTime()
+{
+iTimeToWait = (qAbs(qrand()) % 5) * 1000;
+if (iTimeToWait < 1000) {
+iTimeToWait = 1000;
+}
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+qDebug("QNetworkConfigurationManager waiting random time: %d ms", iTimeToWait);
+#endif
+QTimer::singleShot(iTimeToWait, iIgnoreEventLoop, SLOT(quit()));
+iIgnoreEventLoop->exec();
 }
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> QNetworkConfigurationManagerPrivate::dataByConnectionId(TUint aConnectionId)
 {
 QNetworkConfiguration item;

branch	RCL_3
changeset 1	5822d84012fb
parent 0	cfcbf08528c4
child 5	4ea83c148e84