1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:BSD$

    10 ** You may use this file under the terms of the BSD license as follows:

    11 **

    12 ** "Redistribution and use in source and binary forms, with or without

    13 ** modification, are permitted provided that the following conditions are

    14 ** met:

    15 **   * Redistributions of source code must retain the above copyright

    16 **     notice, this list of conditions and the following disclaimer.

    17 **   * Redistributions in binary form must reproduce the above copyright

    18 **     notice, this list of conditions and the following disclaimer in

    19 **     the documentation and/or other materials provided with the

    20 **     distribution.

    21 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor

    22 **     the names of its contributors may be used to endorse or promote

    23 **     products derived from this software without specific prior written

    24 **     permission.

    25 **

    26 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    27 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    28 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    29 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    30 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    31 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    32 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    33 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    34 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    35 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    36 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

    37 ** $QT_END_LICENSE$

    38 **

    39 ****************************************************************************/

    40 

    41 #include "bearermonitor.h"

    42 #include "sessionwidget.h"

    43 

    44 #include <QDebug>

    45 #include <QMessageBox>

    46 #ifdef Q_OS_WIN

    47 #include <winsock2.h>

    48 #undef interface

    49 

    50 #ifndef NS_NLA

    51 #define NS_NLA 15

    52 #endif

    53 #endif

    54 

    55 BearerMonitor::BearerMonitor(QWidget *parent)

    56 :   QWidget(parent)

    57 {

    58     setupUi(this);

    59 #if defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)

    60     newSessionButton->hide();

    61     deleteSessionButton->hide();

    62 #else

    63     delete tabWidget->currentWidget();

    64     sessionGroup->hide();

    65 #endif

    66 #if defined (Q_OS_SYMBIAN) || defined(Q_OS_WINCE) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)

    67     setWindowState(Qt::WindowMaximized);

    68 #endif

    69     updateConfigurations();

    70 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

    71     onlineStateChanged(!manager.allConfigurations(QNetworkConfiguration::Active).isEmpty());

    72 #endif

    73     QNetworkConfiguration defaultConfiguration = manager.defaultConfiguration();

    74     for (int i = 0; i < treeWidget->topLevelItemCount(); ++i) {

    75         QTreeWidgetItem *item = treeWidget->topLevelItem(i);

    76 

    77         if (item->data(0, Qt::UserRole).toString() == defaultConfiguration.identifier()) {

    78             treeWidget->setCurrentItem(item);

    79             showConfigurationFor(item);

    80             break;

    81         }

    82     }

    83     connect(&manager, SIGNAL(onlineStateChanged(bool)), this ,SLOT(onlineStateChanged(bool)));

    84     connect(&manager, SIGNAL(configurationAdded(const QNetworkConfiguration&)),

    85             this, SLOT(configurationAdded(const QNetworkConfiguration&)));

    86     connect(&manager, SIGNAL(configurationRemoved(const QNetworkConfiguration&)),

    87             this, SLOT(configurationRemoved(const QNetworkConfiguration&)));

    88     connect(&manager, SIGNAL(configurationChanged(const QNetworkConfiguration&)),

    89             this, SLOT(configurationChanged(const QNetworkConfiguration)));

    90     connect(&manager, SIGNAL(updateCompleted()), this, SLOT(updateConfigurations()));

    91 

    92 #ifdef Q_OS_WIN

    93     connect(registerButton, SIGNAL(clicked()), this, SLOT(registerNetwork()));

    94     connect(unregisterButton, SIGNAL(clicked()), this, SLOT(unregisterNetwork()));

    95 #else

    96     nlaGroup->hide();

    97 #endif

    98 

    99     connect(treeWidget, SIGNAL(itemActivated(QTreeWidgetItem*,int)),

   100             this, SLOT(createSessionFor(QTreeWidgetItem*)));

   101 

   102     connect(treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),

   103             this, SLOT(showConfigurationFor(QTreeWidgetItem*)));

   104 

   105     connect(newSessionButton, SIGNAL(clicked()),

   106             this, SLOT(createNewSession()));

   107 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   108     connect(deleteSessionButton, SIGNAL(clicked()),

   109             this, SLOT(deleteSession()));

   110 #endif

   111     connect(scanButton, SIGNAL(clicked()),

   112             this, SLOT(performScan()));

   113 

   114     // Just in case update all configurations so that all

   115     // configurations are up to date.

   116     manager.updateConfigurations();

   117 }

   118 

   119 BearerMonitor::~BearerMonitor()

   120 {

   121 }

   122 

   123 static void updateItem(QTreeWidgetItem *item, const QNetworkConfiguration &config)

   124 {

   125     item->setText(0, config.name());

   126     item->setData(0, Qt::UserRole, config.identifier());

   127 

   128     QFont font = item->font(1);

   129     font.setBold((config.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active);

   130     item->setFont(0, font);

   131 }

   132 

   133 void BearerMonitor::configurationAdded(const QNetworkConfiguration &config, QTreeWidgetItem *parent)

   134 {

   135     QTreeWidgetItem *item = new QTreeWidgetItem;

   136     updateItem(item, config);

   137 

   138     if (parent)

   139         parent->addChild(item);

   140     else

   141         treeWidget->addTopLevelItem(item);

   142 

   143     if (config.type() == QNetworkConfiguration::ServiceNetwork) {

   144         foreach (const QNetworkConfiguration &child, config.children())

   145             configurationAdded(child, item);

   146     }

   147 }

   148 

   149 void BearerMonitor::configurationRemoved(const QNetworkConfiguration &config)

   150 {

   151     for (int i = 0; i < treeWidget->topLevelItemCount(); ++i) {

   152         QTreeWidgetItem *item = treeWidget->topLevelItem(i);

   153 

   154         if (item->data(0, Qt::UserRole).toString() == config.identifier()) {

   155             delete item;

   156             break;

   157         }

   158     }

   159 }

   160 

   161 void BearerMonitor::configurationChanged(const QNetworkConfiguration &config)

   162 {

   163     for (int i = 0; i < treeWidget->topLevelItemCount(); ++i) {

   164         QTreeWidgetItem *item = treeWidget->topLevelItem(i);

   165 

   166         if (item->data(0, Qt::UserRole).toString() == config.identifier()) {

   167             updateItem(item, config);

   168 

   169             if (config.type() == QNetworkConfiguration::ServiceNetwork)

   170                 updateSnapConfiguration(item, config);

   171 

   172             if (item == treeWidget->currentItem())

   173                 showConfigurationFor(item);

   174 

   175             break;

   176         }

   177     }

   178 }

   179 

   180 void BearerMonitor::updateSnapConfiguration(QTreeWidgetItem *parent, const QNetworkConfiguration &snap)

   181 {

   182     QMap<QString, QTreeWidgetItem *> itemMap;

   183     for (int i = 0; i < parent->childCount(); ++i) {

   184         QTreeWidgetItem *item = parent->child(i);

   185         itemMap.insert(item->data(0, Qt::UserRole).toString(), item);

   186     }

   187 

   188     QList<QNetworkConfiguration> allConfigurations = snap.children();

   189 

   190     while (!allConfigurations.isEmpty()) {

   191         QNetworkConfiguration config = allConfigurations.takeFirst();

   192 

   193         QTreeWidgetItem *item = itemMap.take(config.identifier());

   194         if (item) {

   195             updateItem(item, config);

   196 

   197             if (config.type() == QNetworkConfiguration::ServiceNetwork)

   198                 updateSnapConfiguration(item, config);

   199         } else {

   200             configurationAdded(config, parent);

   201         }

   202     }

   203 

   204     foreach (const QString &id, itemMap.keys())

   205         delete itemMap.value(id);

   206 

   207     itemMap.clear();

   208 }

   209 

   210 void BearerMonitor::updateConfigurations()

   211 {

   212     progressBar->hide();

   213     scanButton->show();

   214 

   215     // Just in case update online state, on Symbian platform

   216     // WLAN scan needs to be triggered initially to have their true state.

   217     onlineStateChanged(manager.isOnline());

   218 

   219     QList<QTreeWidgetItem *> items = treeWidget->findItems(QLatin1String("*"), Qt::MatchWildcard);

   220     QMap<QString, QTreeWidgetItem *> itemMap;

   221     while (!items.isEmpty()) {

   222         QTreeWidgetItem *item = items.takeFirst();

   223         itemMap.insert(item->data(0, Qt::UserRole).toString(), item);

   224     }

   225 

   226     QList<QNetworkConfiguration> allConfigurations = manager.allConfigurations();

   227 

   228     while (!allConfigurations.isEmpty()) {

   229         QNetworkConfiguration config = allConfigurations.takeFirst();

   230 

   231         QTreeWidgetItem *item = itemMap.take(config.identifier());

   232         if (item) {

   233             updateItem(item, config);

   234 

   235             if (config.type() == QNetworkConfiguration::ServiceNetwork)

   236                 updateSnapConfiguration(item, config);

   237         } else {

   238             configurationAdded(config);

   239         }

   240     }

   241 

   242     foreach (const QString &id, itemMap.keys())

   243         delete itemMap.value(id);

   244 }

   245 

   246 void BearerMonitor::onlineStateChanged(bool isOnline)

   247 {

   248     if (isOnline)

   249 #if defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)

   250         QMessageBox::information(this, "Connection state changed", "Online", QMessageBox::Close);

   251     else

   252         QMessageBox::information(this, "Connection state changed", "Offline", QMessageBox::Close);

   253 #else

   254         onlineState->setText(tr("Online"));

   255     else

   256         onlineState->setText(tr("Offline"));

   257 #endif

   258 }

   259 

   260 #ifdef Q_OS_WIN

   261 void BearerMonitor::registerNetwork()

   262 {

   263     QTreeWidgetItem *item = treeWidget->currentItem();

   264     if (!item) return;

   265 

   266     QNetworkConfiguration configuration =

   267         manager.configurationFromIdentifier(item->data(0, Qt::UserRole).toString());

   268 

   269     const QString name = configuration.name();

   270 

   271     qDebug() << "Registering" << name << "with system";

   272 

   273     WSAQUERYSET networkInfo;

   274     memset(&networkInfo, 0, sizeof(networkInfo));

   275     networkInfo.dwSize = sizeof(networkInfo);

   276     networkInfo.lpszServiceInstanceName = (LPWSTR)name.utf16();

   277     networkInfo.dwNameSpace = NS_NLA;

   278 

   279     if (WSASetService(&networkInfo, RNRSERVICE_REGISTER, 0) == SOCKET_ERROR)

   280         qDebug() << "WSASetService(RNRSERVICE_REGISTER) returned" << WSAGetLastError();

   281 }

   282 

   283 void BearerMonitor::unregisterNetwork()

   284 {

   285     QTreeWidgetItem *item = treeWidget->currentItem();

   286     if (!item) return;

   287 

   288     QNetworkConfiguration configuration =

   289         manager.configurationFromIdentifier(item->data(0, Qt::UserRole).toString());

   290 

   291     const QString name = configuration.name();

   292 

   293     qDebug() << "Unregistering" << name << "with system";

   294 

   295     WSAQUERYSET networkInfo;

   296     memset(&networkInfo, 0, sizeof(networkInfo));

   297     networkInfo.dwSize = sizeof(networkInfo);

   298     networkInfo.lpszServiceInstanceName = (LPWSTR)name.utf16();

   299     networkInfo.dwNameSpace = NS_NLA;

   300 

   301     if (WSASetService(&networkInfo, RNRSERVICE_DELETE, 0) == SOCKET_ERROR)

   302         qDebug() << "WSASetService(RNRSERVICE_DELETE) returned" << WSAGetLastError();

   303 }

   304 #endif

   305 

   306 void BearerMonitor::showConfigurationFor(QTreeWidgetItem *item)

   307 {

   308     QString identifier;

   309 

   310     if (item)

   311         identifier = item->data(0, Qt::UserRole).toString();

   312 

   313     QNetworkConfiguration conf = manager.configurationFromIdentifier(identifier);

   314 

   315     switch (conf.state()) {

   316     case QNetworkConfiguration::Active:

   317         configurationState->setText(tr("Active"));

   318         break;

   319     case QNetworkConfiguration::Discovered:

   320         configurationState->setText(tr("Discovered"));

   321         break;

   322     case QNetworkConfiguration::Defined:

   323         configurationState->setText(tr("Defined"));

   324         break;

   325     case QNetworkConfiguration::Undefined:

   326         configurationState->setText(tr("Undefined"));

   327         break;

   328     default:

   329         configurationState->setText(QString());

   330     }

   331 

   332     switch (conf.type()) {

   333     case QNetworkConfiguration::InternetAccessPoint:

   334         configurationType->setText(tr("Internet Access Point"));

   335         break;

   336     case QNetworkConfiguration::ServiceNetwork:

   337         configurationType->setText(tr("Service Network"));

   338         break;

   339     case QNetworkConfiguration::UserChoice:

   340         configurationType->setText(tr("User Choice"));

   341         break;

   342     case QNetworkConfiguration::Invalid:

   343         configurationType->setText(tr("Invalid"));

   344         break;

   345     default:

   346         configurationType->setText(QString());

   347     }

   348 

   349     switch (conf.purpose()) {

   350     case QNetworkConfiguration::UnknownPurpose:

   351         configurationPurpose->setText(tr("Unknown"));

   352         break;

   353     case QNetworkConfiguration::PublicPurpose:

   354         configurationPurpose->setText(tr("Public"));

   355         break;

   356     case QNetworkConfiguration::PrivatePurpose:

   357         configurationPurpose->setText(tr("Private"));

   358         break;

   359     case QNetworkConfiguration::ServiceSpecificPurpose:

   360         configurationPurpose->setText(tr("Service Specific"));

   361         break;

   362     default:

   363         configurationPurpose->setText(QString());

   364     }

   365 

   366     configurationIdentifier->setText(conf.identifier());

   367 

   368     configurationRoaming->setText(conf.isRoamingAvailable() ? tr("Available") : tr("Not available"));

   369 

   370     configurationChildren->setText(QString::number(conf.children().count()));

   371 

   372     configurationName->setText(conf.name());

   373 }

   374 

   375 void BearerMonitor::createSessionFor(QTreeWidgetItem *item)

   376 {

   377     const QString identifier = item->data(0, Qt::UserRole).toString();

   378 

   379     QNetworkConfiguration conf = manager.configurationFromIdentifier(identifier);

   380 

   381     SessionWidget *session = new SessionWidget(conf);

   382 

   383     tabWidget->addTab(session, conf.name());

   384 

   385 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   386     sessionGroup->show();

   387 #endif

   388 

   389     sessionWidgets.append(session);

   390 }

   391 

   392 void BearerMonitor::createNewSession()

   393 {

   394     QTreeWidgetItem *item = treeWidget->currentItem();

   395     if (!item) return;

   396 

   397     createSessionFor(item);

   398 }

   399 

   400 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   401 void BearerMonitor::deleteSession()

   402 {

   403     SessionWidget *session = qobject_cast<SessionWidget *>(tabWidget->currentWidget());

   404     if (session) {

   405         sessionWidgets.removeAll(session);

   406 

   407         delete session;

   408 

   409         if (tabWidget->count() == 0)

   410             sessionGroup->hide();

   411     }

   412 }

   413 #endif

   414 

   415 void BearerMonitor::performScan()

   416 {

   417     scanButton->hide();

   418     progressBar->show();

   419     manager.updateConfigurations();

   420 }