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

equal deleted inserted replaced

-:4ea83c148e84
+:4203353e74ea
 #include <aputils.h>
 #endif
 QTM_BEGIN_NAMESPACE
-#ifdef SNAP_FUNCTIONALITY_AVAILABLE
-static const int KValueThatWillBeAddedToSNAPId = 1000;
-#endif
 static const int KUserChoiceIAPId = 0;
 QNetworkConfigurationManagerPrivate::QNetworkConfigurationManagerPrivate()
-: QObject(0), CActive(CActive::EPriorityIdle), capFlags(0),
+: QObject(0), CActive(CActive::EPriorityHigh), capFlags(0),
 iFirstUpdate(true), iInitOk(true), iUpdatePending(false),
 iTimeToWait(0)
 {
 CActiveScheduler::Add(this);
 iInitOk = false;
 return;
 }
 TRAP_IGNORE(iConnectionMonitor.ConnectL());
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+TRAP_IGNORE(iConnectionMonitor.SetUintAttribute(EBearerIdAll, 0, KBearerGroupThreshold, 1));
+#endif
 TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 TRAP(error, iCmManager.OpenL());
 if (error != KErrNone) {
 void QNetworkConfigurationManagerPrivate::updateConfigurations()
 {
 if (!iInitOk) {
 return;
 }
 TRAP_IGNORE(updateConfigurationsL());
 }
 void QNetworkConfigurationManagerPrivate::updateConfigurationsL()
 {
 iCmManager.ConnectionMethodL(connectionMethods);
 for(int i = 0; i < connectionMethods.Count(); i++) {
 RCmConnectionMethod connectionMethod = iCmManager.ConnectionMethodL(connectionMethods[i]);
 CleanupClosePushL(connectionMethod);
 TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
-QString ident = QString::number(qHash(iapId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(iapId));
 if (accessPointConfigurations.contains(ident)) {
 knownConfigs.removeOne(ident);
 } else {
 QNetworkConfigurationPrivate* cpPriv = NULL;
 TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
 iCmManager.AllDestinationsL(destinations);
 for(int i = 0; i < destinations.Count(); i++) {
 RCmDestination destination;
 destination = iCmManager.DestinationL(destinations[i]);
 CleanupClosePushL(destination);
-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
+QString ident = QT_BEARERMGMT_CONFIGURATION_SNAP_PREFIX+QString::number(qHash(destination.Id()));
 if (snapConfigurations.contains(ident)) {
 knownSnapConfigs.removeOne(ident);
 } else {
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
 for (int j=0; j < destination.ConnectionMethodCount(); j++) {
 RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);
 CleanupClosePushL(connectionMethod);
 TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
-QString iface = QString::number(qHash(iapId));
+QString iface = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(iapId));
 // Check that IAP can be found from accessPointConfigurations list
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data() == 0) {
 QNetworkConfigurationPrivate* cpPriv = NULL;
 TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
 // Loop through all IAPs
 TUint32 apId = 0;
 TInt retVal = pDbTView->GotoFirstRecord();
 while (retVal == KErrNone) {
 pDbTView->ReadUintL(TPtrC(COMMDB_ID), apId);
-QString ident = QString::number(qHash(apId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(apId));
 if (accessPointConfigurations.contains(ident)) {
 knownConfigs.removeOne(ident);
 } else {
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
 if (readNetworkConfigurationValuesFromCommsDb(apId, cpPriv)) {
 QNetworkConfigurationPrivate* QNetworkConfigurationManagerPrivate::configFromConnectionMethodL(
 RCmConnectionMethod& connectionMethod)
 {
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
 TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
-QString ident = QString::number(qHash(iapId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(iapId));
 HBufC *pName = connectionMethod.GetStringAttributeL(CMManager::ECmName);
 CleanupStack::PushL(pName);
 QT_TRYCATCH_LEAVING(cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length()));
 CleanupStack::PopAndDestroy(pName);
 if (name.Compare(_L("Easy WLAN")) == 0) {
 // "Easy WLAN" won't be accepted to the Configurations list
 User::Leave(KErrNotFound);
 }
-QString ident = QString::number(qHash(aApId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(aApId));
 QT_TRYCATCH_LEAVING(apNetworkConfiguration->name = QString::fromUtf16(name.Ptr(),name.Length()));
 apNetworkConfiguration->isValid = true;
 apNetworkConfiguration->id = ident;
 apNetworkConfiguration->numericId = aApId;
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 // Check Default Connection (SNAP or IAP)
 TCmDefConnValue defaultConnectionValue;
 iCmManager.ReadDefConnL(defaultConnectionValue);
 if (defaultConnectionValue.iType == ECmDefConnDestination) {
-QString iface = QString::number(qHash(defaultConnectionValue.iId+KValueThatWillBeAddedToSNAPId));
+QString iface = QT_BEARERMGMT_CONFIGURATION_SNAP_PREFIX+QString::number(qHash(defaultConnectionValue.iId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.value(iface);
 if (priv.data() != 0) {
 item.d = priv;
 }
 } else if (defaultConnectionValue.iType == ECmDefConnConnectionMethod) {
-QString iface = QString::number(qHash(defaultConnectionValue.iId));
+QString iface = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(defaultConnectionValue.iId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(iface);
 if (priv.data() != 0) {
 item.d = priv;
 }
 }
 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));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(apId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+#ifdef OCC_FUNCTIONALITY_AVAILABLE
+if (!priv.data()) {
+// If IAP was not found, check if the update was about EasyWLAN
+priv = configurationFromEasyWlan(apId, connectionId);
+}
+#endif
 if (priv.data()) {
 iConnectionMonitor.GetIntAttribute(connectionId, subConnectionCount, KConnectionStatus, connectionStatus, status);
 User::WaitForRequest(status);
 if (connectionStatus == KLinkLayerOpen) {
 online = true;
 }
 }
 if (iOnline != online) {
 iOnline = online;
-emit this->onlineStateChanged(iOnline);
+emit this->onlineStateChanged(online);
 }
 }
 void QNetworkConfigurationManagerPrivate::updateAvailableAccessPoints()
 {
 QList<QString> unavailableConfigs = accessPointConfigurations.keys();
 // Set state of returned IAPs to Discovered
 // if state is not already Active
 for(TUint i=0; i<iapInfo.iCount; i++) {
-QString ident = QString::number(qHash(iapInfo.iIap[i].iIapId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(iapInfo.iIap[i].iIapId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
 if (priv.data()) {
 unavailableConfigs.removeOne(ident);
 if (priv.data()->state < QNetworkConfiguration::Active) {
 // Configuration is either Discovered or Active
 changeConfigurationStateTo(priv, QNetworkConfiguration::Defined);
 }
 }
 }
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+void QNetworkConfigurationManagerPrivate::updateMobileBearerToConfigs(TConnMonBearerInfo bearerInfo)
+{
+foreach (const QString &ii, accessPointConfigurations.keys()) {
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> p =
+accessPointConfigurations.value(ii);
+if (p->bearer >= QNetworkConfigurationPrivate::Bearer2G &&
+p->bearer <= QNetworkConfigurationPrivate::BearerHSPA) {
+switch (bearerInfo) {
+case EBearerInfoCSD:      p->bearer = QNetworkConfigurationPrivate::Bearer2G; break;
+case EBearerInfoWCDMA:    p->bearer = QNetworkConfigurationPrivate::BearerWCDMA; break;
+case EBearerInfoCDMA2000: p->bearer = QNetworkConfigurationPrivate::BearerCDMA2000; break;
+case EBearerInfoGPRS:     p->bearer = QNetworkConfigurationPrivate::Bearer2G; break;
+case EBearerInfoHSCSD:    p->bearer = QNetworkConfigurationPrivate::Bearer2G; break;
+case EBearerInfoEdgeGPRS: p->bearer = QNetworkConfigurationPrivate::Bearer2G; break;
+case EBearerInfoWcdmaCSD: p->bearer = QNetworkConfigurationPrivate::BearerWCDMA; break;
+case EBearerInfoHSDPA:    p->bearer = QNetworkConfigurationPrivate::BearerHSPA; break;
+case EBearerInfoHSUPA:    p->bearer = QNetworkConfigurationPrivate::BearerHSPA; break;
+case EBearerInfoHSxPA:    p->bearer = QNetworkConfigurationPrivate::BearerHSPA; break;
+}
+}
+}
+}
+#endif
 bool QNetworkConfigurationManagerPrivate::changeConfigurationStateTo(QExplicitlySharedDataPointer<QNetworkConfigurationPrivate>& sharedData,
 QNetworkConfiguration::StateFlags newState)
 {
 if (newState != sharedData.data()->state) {
 sharedData.data()->state = newState;
 }
 void QNetworkConfigurationManagerPrivate::RunL()
 {
 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::ECommit:   /** A transaction has been committed.  */
 case RDbNotifier::ERecover:  /** The database has been recovered    */
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug("QNCM CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
+#endif
 // Mark that there is update pending. No need to ask more events,
 // as we know we will be updating anyway when the timer expires.
 if (!iUpdatePending) {
 iUpdatePending = true;
 iWaitingCommsDatabaseNotifications = false;
 }
 void QNetworkConfigurationManagerPrivate::EventL(const CConnMonEventBase& aEvent)
 {
 switch (aEvent.EventType()) {
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+case EConnMonBearerInfoChange:
+{
+CConnMonBearerInfoChange* realEvent;
+realEvent = (CConnMonBearerInfoChange*) &aEvent;
+TUint connectionId = realEvent->ConnectionId();
+if (connectionId == EBearerIdAll) {
+//Network level event
+TConnMonBearerInfo bearerInfo = (TConnMonBearerInfo)realEvent->BearerInfo();
+updateMobileBearerToConfigs(bearerInfo);
+}
+break;
+}
+#endif
 case EConnMonConnectionStatusChange:
 {
 CConnMonConnectionStatusChange* realEvent;
 realEvent = (CConnMonConnectionStatusChange*) &aEvent;
 TInt connectionStatus = realEvent->ConnectionStatus();
 TUint subConnectionCount = 0;
 TUint apId;
 TRequestStatus status;
 iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
 User::WaitForRequest(status);
-QString ident = QString::number(qHash(apId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(apId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+#ifdef OCC_FUNCTIONALITY_AVAILABLE
+if (!priv.data()) {
+// Check if status was regarding EasyWLAN
+priv = configurationFromEasyWlan(apId, connectionId);
+}
+#endif
 if (priv.data()) {
 priv.data()->connectionId = connectionId;
 QT_TRYCATCH_LEAVING(emit this->configurationStateChanged(priv.data()->numericId, connectionId, QNetworkSession::Connecting));
 }
 } else if (connectionStatus == KLinkLayerOpen) {
 // Connection has been successfully opened
 TUint connectionId = realEvent->ConnectionId();
 TUint subConnectionCount = 0;
 TUint apId;
 TRequestStatus status;
 iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
 User::WaitForRequest(status);
-QString ident = QString::number(qHash(apId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(apId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+#ifdef OCC_FUNCTIONALITY_AVAILABLE
+if (!priv.data()) {
+// Check for EasyWLAN
+priv = configurationFromEasyWlan(apId, connectionId);
+}
+#endif
 if (priv.data()) {
 priv.data()->connectionId = connectionId;
 // Configuration is Active
 QT_TRYCATCH_LEAVING(
 if (changeConfigurationStateTo(priv, QNetworkConfiguration::Active)) {
 CConnMonIapAvailabilityChange* realEvent;
 realEvent = (CConnMonIapAvailabilityChange*) &aEvent;
 TConnMonIapInfo iaps = realEvent->IapAvailability();
 QList<QString> unDiscoveredConfigs = accessPointConfigurations.keys();
 for ( TUint i = 0; i < iaps.Count(); i++ ) {
-QString ident = QString::number(qHash(iaps.iIap[i].iIapId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(iaps.iIap[i].iIapId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
 if (priv.data()) {
 // Configuration is either Discovered or Active
 QT_TRYCATCH_LEAVING(changeConfigurationStateAtMinTo(priv, QNetworkConfiguration::Discovered));
 unDiscoveredConfigs.removeOne(ident);
 TUint apId;
 TUint connectionId = realEvent->ConnectionId();
 TRequestStatus status;
 iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
 User::WaitForRequest(status);
-QString ident = QString::number(qHash(apId));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+QString::number(qHash(apId));
 QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.value(ident);
+#ifdef OCC_FUNCTIONALITY_AVAILABLE
+if (!priv.data()) {
+// If IAP was not found, check if the update was about EasyWLAN
+priv = configurationFromEasyWlan(apId, connectionId);
+}
+#endif
 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;
 default:
 // For unrecognized events
 break;
 }
 }
+#ifdef OCC_FUNCTIONALITY_AVAILABLE
+// Tries to derive configuration from EasyWLAN.
+// First checks if the interface brought up was EasyWLAN, then derives the real SSID,
+// and looks up configuration based on that one.
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> QNetworkConfigurationManagerPrivate::configurationFromEasyWlan(TUint32 apId, TUint connectionId)
+{
+if (apId == iCmManager.EasyWlanIdL()) {
+TRequestStatus status;
+TBuf<50> easyWlanNetworkName;
+iConnectionMonitor.GetStringAttribute( connectionId, 0, KNetworkName,
+easyWlanNetworkName, status );
+User::WaitForRequest(status);
+if (status.Int() == KErrNone) {
+QString realSSID = QString::fromUtf16(easyWlanNetworkName.Ptr(), easyWlanNetworkName.Length());
+// Browser through all items and check their name for match
+QNetworkConfiguration item;
+QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> >::const_iterator i =
+accessPointConfigurations.constBegin();
+while (i != accessPointConfigurations.constEnd()) {
+QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = i.value();
+if (priv.data()->name == realSSID) {
+#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
+qDebug() << "QNCM EasyWlan uses real SSID: " << realSSID;
+#endif
+return priv;
+}
+++i;
+}
+}
+}
+return QExplicitlySharedDataPointer<QNetworkConfigurationPrivate>();
+}
+#endif
 // Sessions may use this function to report configuration state changes,
 // because on some Symbian platforms (especially Symbian^3) all state changes are not
 // reported by the RConnectionMonitor, in particular in relation to stop() call,
 // whereas they _are_ reported on RConnection progress notifier used by sessions --> centralize
 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));
+QString ident = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+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();
 if (priv.data()->connectionId == aConnectionId) {
 return priv;
 }
 ++i;
 }
 return QExplicitlySharedDataPointer<QNetworkConfigurationPrivate>();
 }
 AccessPointsAvailabilityScanner::AccessPointsAvailabilityScanner(QNetworkConfigurationManagerPrivate& owner,
 RConnectionMonitor& connectionMonitor)

branch	RCL_3
changeset 13	4203353e74ea
parent 10	4ea83c148e84
child 21	885c2596c964