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

equal deleted inserted replaced

-:d965ea371a4f
+:4ea83c148e84
 #include "qnetworkconfigmanager_s60_p.h"
 #include <commdb.h>
 #include <cdbcols.h>
 #include <d32dbms.h>
-#include <QEventLoop>
+#include <nifvar.h>
 #include <QTimer>
 #include <QTime>  // For randgen seeding
 #include <QtCore> // For randgen seeding
-// #define QT_BEARERMGMT_CONFIGMGR_DEBUG
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
-#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
 #include <QDebug>
 #endif
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 #include <cmdestination.h>
 #include <aputils.h>
 #endif
 QTM_BEGIN_NAMESPACE
-static const int KValueThatWillBeAddedToSNAPId = 1000;
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+static const int KValueThatWillBeAddedToSNAPId = 1000;
+#endif
 static const int KUserChoiceIAPId = 0;
 QNetworkConfigurationManagerPrivate::QNetworkConfigurationManagerPrivate()
 : QObject(0), CActive(CActive::EPriorityIdle), capFlags(0),
-iFirstUpdate(true), iInitOk(true), iIgnoringUpdates(false),
+iFirstUpdate(true), iInitOk(true), iUpdatePending(false),
-iTimeToWait(0), iIgnoreEventLoop(0)
+iTimeToWait(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;
 CTrapCleanup* cleanup = CTrapCleanup::New();
 delete ipCommsDB;
 delete cleanup;
 }
+void QNetworkConfigurationManagerPrivate::delayedConfigurationUpdate()
+{
+if (iUpdatePending) {
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug("QNCM delayed configuration update (ECommit or ERecover occurred).");
+#endif
+TRAPD(error, updateConfigurationsL());
+if (error == KErrNone) {
+updateStatesToSnaps();
+}
+iUpdatePending = false;
+// Start monitoring again.
+if (!IsActive()) {
+SetActive();
+// Start waiting for new notification
+ipCommsDB->RequestNotification(iStatus);
+}
+}
+}
 void QNetworkConfigurationManagerPrivate::registerPlatformCapabilities()
 {
 capFlags |= QNetworkConfigurationManager::CanStartAndStopInterfaces;
 capFlags |= QNetworkConfigurationManager::DirectConnectionRouting;
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv);
 accessPointConfigurations.insert(cpPriv->id, ptr);
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = ptr;
-emit configurationAdded(item);
+// Emit configuration added. Connected slots may throw execptions
+// which propagate here --> must be converted to leaves (standard
+// std::exception would cause any TRAP trapping this function to terminate
+// program).
+QT_TRYCATCH_LEAVING(emit configurationAdded(item));
 }
 }
 }
 CleanupStack::PopAndDestroy(&connectionMethod);
 }
 QString ident = QString::number(qHash(destination.Id()+KValueThatWillBeAddedToSNAPId)); //TODO: Check if it's ok to add 1000 SNAP Id to prevent SNAP ids overlapping IAP ids
 if (snapConfigurations.contains(ident)) {
 knownSnapConfigs.removeOne(ident);
 } else {
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
-CleanupStack::PushL(cpPriv);
 HBufC *pName = destination.NameLC();
-cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+QT_TRYCATCH_LEAVING(cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length()));
 CleanupStack::PopAndDestroy(pName);
 pName = NULL;
 cpPriv->isValid = true;
 cpPriv->id = ident;
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv);
 snapConfigurations.insert(ident, ptr);
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = ptr;
-emit configurationAdded(item);
+QT_TRYCATCH_LEAVING(emit configurationAdded(item));
 }
-CleanupStack::Pop(cpPriv);
 }
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> privSNAP = snapConfigurations.value(ident);
 for (int j=0; j < destination.ConnectionMethodCount(); j++) {
 RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);
 ptr.data()->serviceNetworkPtr = privSNAP;
 accessPointConfigurations.insert(cpPriv->id, ptr);
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = ptr;
-emit configurationAdded(item);
+QT_TRYCATCH_LEAVING(emit configurationAdded(item));
 }
 privSNAP->serviceNetworkMembers.append(ptr);
 }
 } else {
 knownConfigs.removeOne(iface);
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv);
 accessPointConfigurations.insert(ident, ptr);
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = ptr;
-emit configurationAdded(item);
+QT_TRYCATCH_LEAVING(emit configurationAdded(item));
 }
 } else {
 delete cpPriv;
 }
 }
 retVal = pDbTView->GotoNextRecord();
 }
 CleanupStack::PopAndDestroy(pDbTView);
 #endif
-updateActiveAccessPoints();
+QT_TRYCATCH_LEAVING(updateActiveAccessPoints());
 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);
+QT_TRYCATCH_LEAVING(emit configurationRemoved(item));
 }
 // Remove non existing IAP from SNAPs
 foreach (const QString &iface, snapConfigurations.keys()) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv2 = snapConfigurations.value(iface);
 // => Check if one of the IAPs of the SNAP is active
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.take(oldIface);
 priv->isValid = false;
 if (!iFirstUpdate) {
 QNetworkConfiguration item;
 item.d = priv;
-emit configurationRemoved(item);
+QT_TRYCATCH_LEAVING(emit configurationRemoved(item));
 }
 }
 }
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 QNetworkConfigurationPrivate* QNetworkConfigurationManagerPrivate::configFromConnectionMethodL(
 RCmConnectionMethod& connectionMethod)
 {
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
-CleanupStack::PushL(cpPriv);
 TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
 QString ident = QString::number(qHash(iapId));
 HBufC *pName = connectionMethod.GetStringAttributeL(CMManager::ECmName);
 CleanupStack::PushL(pName);
-cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+QT_TRYCATCH_LEAVING(cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length()));
 CleanupStack::PopAndDestroy(pName);
 pName = NULL;
 TUint32 bearerId = connectionMethod.GetIntAttributeL(CMManager::ECmCommsDBBearerType);
 switch (bearerId) {
 TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EDialDefaultTelNum));
 }
 if (error == KErrNone && pName) {
 CleanupStack::PushL(pName);
-cpPriv->mappingName = QString::fromUtf16(pName->Ptr(),pName->Length());
+QT_TRYCATCH_LEAVING(cpPriv->mappingName = QString::fromUtf16(pName->Ptr(),pName->Length()));
 CleanupStack::PopAndDestroy(pName);
 pName = NULL;
 }
 cpPriv->state = QNetworkConfiguration::Defined;
 cpPriv->connectionId = 0;
 cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
 cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
 cpPriv->roamingSupported = false;
 cpPriv->manager = this;
-CleanupStack::Pop(cpPriv);
 return cpPriv;
 }
 #else
 bool QNetworkConfigurationManagerPrivate::readNetworkConfigurationValuesFromCommsDb(
 TUint32 aApId, QNetworkConfigurationPrivate* apNetworkConfiguration)
 User::Leave(KErrNotFound);
 }
 QString ident = QString::number(qHash(aApId));
-apNetworkConfiguration->name = QString::fromUtf16(name.Ptr(),name.Length());
+QT_TRYCATCH_LEAVING(apNetworkConfiguration->name = QString::fromUtf16(name.Ptr(),name.Length()));
 apNetworkConfiguration->isValid = true;
 apNetworkConfiguration->id = ident;
 apNetworkConfiguration->numericId = aApId;
 apNetworkConfiguration->connectionId = 0;
 apNetworkConfiguration->state = (QNetworkConfiguration::Defined);
 TRequestStatus status;
 TUint connectionCount;
 iConnectionMonitor.GetConnectionCount(connectionCount, status);
 User::WaitForRequest(status);
-// Go through all connections and set state of related IAPs to Active
+// Go through all connections and set state of related IAPs to Active.
+// Status needs to be checked carefully, because ConnMon lists also e.g.
+// WLAN connections that are being currently tried --> we don't want to
+// state these as active.
 TUint connectionId;
 TUint subConnectionCount;
 TUint apId;
+TInt connectionStatus;
 if (status.Int() == KErrNone) {
 for (TUint i = 1; i <= connectionCount; i++) {
 iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);
 iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
 User::WaitForRequest(status);
 QString ident = QString::number(qHash(apId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
 if (priv.data()) {
-online = true;
+iConnectionMonitor.GetIntAttribute(connectionId, subConnectionCount, KConnectionStatus, connectionStatus, status);
-inactiveConfigs.removeOne(ident);
+User::WaitForRequest(status);
-priv.data()->connectionId = connectionId;
+if (connectionStatus == KLinkLayerOpen) {
-// Configuration is Active
+online = true;
-changeConfigurationStateTo(priv, QNetworkConfiguration::Active);
+inactiveConfigs.removeOne(ident);
+priv.data()->connectionId = connectionId;
+// Configuration is Active
+changeConfigurationStateTo(priv, QNetworkConfiguration::Active);
+}
 }
 }
 }
 // Make sure that state of rest of the IAPs won't be Active
 changeConfigurationStateAtMinTo(priv, QNetworkConfiguration::Discovered);
 }
 }
 }
-// Make sure that state of rest of the IAPs won't be Discovered or Active
+// Make sure that state of rest of the IAPs won't be Active
 foreach (const QString &iface, unavailableConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()) {
 // Configuration is Defined
-changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Defined);
+changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Discovered);
 }
 }
 }
 updateStatesToSnaps();
 }
 }
 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) {
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug("QNCM CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
+#endif
+// By default, start relistening notifications. Stop only if interesting event occured.
+iWaitingCommsDatabaseNotifications = true;
 RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
 switch (event) {
-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    */
-#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+// Mark that there is update pending. No need to ask more events,
-qDebug("CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
+// as we know we will be updating anyway when the timer expires.
-#endif
+if (!iUpdatePending) {
-iIgnoringUpdates = true;
+iUpdatePending = true;
-// Other events than ECommit get lower priority. In practice with those events,
+iWaitingCommsDatabaseNotifications = false;
-// we delay_before_updating methods, whereas
+// Update after random time, so that many processes won't
-// with ECommit we _update_before_delaying the reaction to next event.
+// start updating simultaneously
-// Few important notes: 1) listening to only ECommit does not seem to be adequate,
+updateConfigurationsAfterRandomTime();
-// 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
+break;
-// 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;
 }
 }
 void QNetworkConfigurationManagerPrivate::DoCancel()
 {
 ipCommsDB->CancelRequestNotification();
 }
 void QNetworkConfigurationManagerPrivate::EventL(const CConnMonEventBase& aEvent)
 {
 switch (aEvent.EventType()) {
-case EConnMonCreateConnection:
+case EConnMonConnectionStatusChange:
 {
-CConnMonCreateConnection* realEvent;
+CConnMonConnectionStatusChange* realEvent;
-realEvent = (CConnMonCreateConnection*) &aEvent;
+realEvent = (CConnMonConnectionStatusChange*) &aEvent;
-TUint subConnectionCount = 0;
+TInt connectionStatus = realEvent->ConnectionStatus();
-TUint apId;
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
-TUint connectionId = realEvent->ConnectionId();
+qDebug() << "QNCM Connection status : " << QString::number(connectionStatus) << " , connection monitor Id : " << realEvent->ConnectionId();
-TRequestStatus status;
+#endif
-iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+if (connectionStatus == KConfigDaemonStartingRegistration) {
-User::WaitForRequest(status);
+TUint connectionId = realEvent->ConnectionId();
-QString ident = QString::number(qHash(apId));
+TUint subConnectionCount = 0;
-QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+TUint apId;
-if (priv.data()) {
+TRequestStatus status;
-priv.data()->connectionId = connectionId;
+iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
-// Configuration is Active
+User::WaitForRequest(status);
-if (changeConfigurationStateTo(priv, QNetworkConfiguration::Active)) {
+QString ident = QString::number(qHash(apId));
-updateStatesToSnaps();
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
-}
+if (priv.data()) {
-if (!iOnline) {
+priv.data()->connectionId = connectionId;
-iOnline = true;
+QT_TRYCATCH_LEAVING(emit this->configurationStateChanged(priv.data()->numericId, connectionId, QNetworkSession::Connecting));
-emit this->onlineStateChanged(iOnline);
+}
-}
+} else if (connectionStatus == KLinkLayerOpen) {
-}
+// Connection has been successfully opened
-}
+TUint connectionId = realEvent->ConnectionId();
-break;
+TUint subConnectionCount = 0;
+TUint apId;
-case EConnMonDeleteConnection:
+TRequestStatus status;
-{
+iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
-CConnMonDeleteConnection* realEvent;
+User::WaitForRequest(status);
-realEvent = (CConnMonDeleteConnection*) &aEvent;
+QString ident = QString::number(qHash(apId));
-TUint connectionId = realEvent->ConnectionId();
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
-QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = dataByConnectionId(connectionId);
+if (priv.data()) {
-if (priv.data()) {
+priv.data()->connectionId = connectionId;
-priv.data()->connectionId = 0;
+// Configuration is Active
-// Configuration is either Defined or Discovered
+QT_TRYCATCH_LEAVING(
-if (changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Discovered)) {
+if (changeConfigurationStateTo(priv, QNetworkConfiguration::Active)) {
 updateStatesToSnaps();
 }
-}
+emit this->configurationStateChanged(priv.data()->numericId, connectionId, QNetworkSession::Connected);
+if (!iOnline) {
-bool online = false;
+iOnline = true;
-foreach (const QString &iface, accessPointConfigurations.keys()) {
+emit this->onlineStateChanged(iOnline);
-QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
+}
-if (priv.data()->state == QNetworkConfiguration::Active) {
+);
-online = true;
+}
-break;
+} else if (connectionStatus == KConfigDaemonStartingDeregistration) {
-}
+TUint connectionId = realEvent->ConnectionId();
-}
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = dataByConnectionId(connectionId);
-if (iOnline != online) {
+if (priv.data()) {
-iOnline = online;
+QT_TRYCATCH_LEAVING(emit this->configurationStateChanged(priv.data()->numericId, connectionId, QNetworkSession::Closing));
-emit this->onlineStateChanged(iOnline);
+}
-}
+} else if (connectionStatus == KLinkLayerClosed ||
-}
+connectionStatus == KConnectionClosed) {
-break;
+// Connection has been closed. Which of the above events is reported, depends on the Symbian
+// platform.
+TUint connectionId = realEvent->ConnectionId();
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = dataByConnectionId(connectionId);
+if (priv.data()) {
+// Configuration is either Defined or Discovered
+QT_TRYCATCH_LEAVING(
+if (changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Discovered)) {
+updateStatesToSnaps();
+}
+emit this->configurationStateChanged(priv.data()->numericId, connectionId, QNetworkSession::Disconnected);
+);
+}
+bool online = false;
+foreach (const QString &iface, accessPointConfigurations.keys()) {
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
+if (priv.data()->state == QNetworkConfiguration::Active) {
+online = true;
+break;
+}
+}
+if (iOnline != online) {
+iOnline = online;
+QT_TRYCATCH_LEAVING(emit this->onlineStateChanged(iOnline));
+}
+}
+}
+break;
 case EConnMonIapAvailabilityChange:
 {
 CConnMonIapAvailabilityChange* realEvent;
 realEvent = (CConnMonIapAvailabilityChange*) &aEvent;
 for ( TUint i = 0; i < iaps.Count(); i++ ) {
 QString ident = QString::number(qHash(iaps.iIap[i].iIapId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
 if (priv.data()) {
 // Configuration is either Discovered or Active
-changeConfigurationStateAtMinTo(priv, QNetworkConfiguration::Discovered);
+QT_TRYCATCH_LEAVING(changeConfigurationStateAtMinTo(priv, QNetworkConfiguration::Discovered));
 unDiscoveredConfigs.removeOne(ident);
 }
 }
 foreach (const QString &iface, unDiscoveredConfigs) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data()) {
 // Configuration is Defined
-changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Defined);
+QT_TRYCATCH_LEAVING(changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Defined));
 }
 }
 }
 break;
+case EConnMonCreateConnection:
+{
+// This event is caught to keep connection monitor IDs up-to-date.
+CConnMonCreateConnection* realEvent;
+realEvent = (CConnMonCreateConnection*) &aEvent;
+TUint subConnectionCount = 0;
+TUint apId;
+TUint connectionId = realEvent->ConnectionId();
+TRequestStatus status;
+iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+User::WaitForRequest(status);
+QString ident = QString::number(qHash(apId));
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+if (priv.data()) {
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug() << "QNCM updating connection monitor ID : from, to, whose: " << priv.data()->connectionId << connectionId << priv->name;
+#endif
+priv.data()->connectionId = connectionId;
+}
+}
+break;
 default:
 // For unrecognized events
 break;
 }
 }
-// Waits for 1..4 seconds.
+// Sessions may use this function to report configuration state changes,
-void QNetworkConfigurationManagerPrivate::waitRandomTime()
+// because on some Symbian platforms (especially Symbian^3) all state changes are not
-{
+// reported by the RConnectionMonitor, in particular in relation to stop() call,
-iTimeToWait = (qAbs(qrand()) % 5) * 1000;
+// whereas they _are_ reported on RConnection progress notifier used by sessions --> centralize
+// this data here so that other sessions may benefit from it too (not all sessions necessarily have
+// RConnection progress notifiers available but they relay on having e.g. disconnected information from
+// manager). Currently only 'Disconnected' state is of interest because it has proven to be troublesome.
+void QNetworkConfigurationManagerPrivate::configurationStateChangeReport(TUint32 accessPointId, QNetworkSession::State newState)
+{
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug() << "QNCM A session reported state change for IAP ID: " << accessPointId << " whose new state is: " << newState;
+#endif
+switch (newState) {
+case QNetworkSession::Disconnected:
+{
+QString ident = QString::number(qHash(accessPointId));
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+if (priv.data()) {
+// Configuration is either Defined or Discovered
+if (changeConfigurationStateAtMaxTo(priv, QNetworkConfiguration::Discovered)) {
+updateStatesToSnaps();
+}
+emit this->configurationStateChanged(
+priv.data()->numericId, priv.data()->connectionId, QNetworkSession::Disconnected);
+}
+}
+break;
+default:
+break;
+}
+}
+// Waits for 2..6 seconds.
+void QNetworkConfigurationManagerPrivate::updateConfigurationsAfterRandomTime()
+{
+iTimeToWait = (qAbs(qrand()) % 68) * 100;
 if (iTimeToWait < 1000) {
 iTimeToWait = 1000;
 }
-#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
-qDebug("QNetworkConfigurationManager waiting random time: %d ms", iTimeToWait);
+qDebug("QNCM waiting random time: %d ms", iTimeToWait);
 #endif
-QTimer::singleShot(iTimeToWait, iIgnoreEventLoop, SLOT(quit()));
+QTimer::singleShot(iTimeToWait, this, SLOT(delayedConfigurationUpdate()));
-iIgnoreEventLoop->exec();
 }
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> QNetworkConfigurationManagerPrivate::dataByConnectionId(TUint aConnectionId)
 {
 QNetworkConfiguration item;
 QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> >::const_iterator i =
 accessPointConfigurations.constBegin();
 while (i != accessPointConfigurations.constEnd()) {
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = i.value();
 if (priv.data()->connectionId == aConnectionId) {
 return QExplicitlySharedDataPointer<QNetworkConfigurationPrivate>();
 }
 AccessPointsAvailabilityScanner::AccessPointsAvailabilityScanner(QNetworkConfigurationManagerPrivate& owner,
 RConnectionMonitor& connectionMonitor)
-: CActive(CActive::EPriorityStandard), iOwner(owner), iConnectionMonitor(connectionMonitor)
+: CActive(CActive::EPriorityHigh), iOwner(owner), iConnectionMonitor(connectionMonitor)
 {
 CActiveScheduler::Add(this);
 }
 AccessPointsAvailabilityScanner::~AccessPointsAvailabilityScanner()
 void AccessPointsAvailabilityScanner::RunL()
 {
 if (iStatus.Int() != KErrNone) {
 iIapBuf().iCount = 0;
-iOwner.accessPointScanningReady(false,iIapBuf());
+QT_TRYCATCH_LEAVING(iOwner.accessPointScanningReady(false,iIapBuf()));
 } else {
-iOwner.accessPointScanningReady(true,iIapBuf());
+QT_TRYCATCH_LEAVING(iOwner.accessPointScanningReady(true,iIapBuf()));
 }
 }
 #include "moc_qnetworkconfigmanager_s60_p.cpp"
 QTM_END_NAMESPACE

branch	RCL_3
changeset 5	4ea83c148e84
parent 1	5822d84012fb
child 6	4203353e74ea