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 examples of the Qt Toolkit.

     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 

    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     connect(&manager, SIGNAL(onlineStateChanged(bool)), this ,SLOT(onlineStateChanged(bool)));

    92 

    93 #ifdef Q_OS_WIN

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

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

    96 #else

    97     nlaGroup->hide();

    98 #endif

    99 

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

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

   102 

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

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

   105 

   106     connect(newSessionButton, SIGNAL(clicked()),

   107             this, SLOT(createNewSession()));

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

   109     connect(deleteSessionButton, SIGNAL(clicked()),

   110             this, SLOT(deleteSession()));

   111 #endif

   112     connect(scanButton, SIGNAL(clicked()),

   113             this, SLOT(performScan()));

   114 }

   115 

   116 BearerMonitor::~BearerMonitor()

   117 {

   118 }

   119 

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

   121 {

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

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

   124 

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

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

   127     item->setFont(0, font);

   128 }

   129 

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

   131 {

   132     QTreeWidgetItem *item = new QTreeWidgetItem;

   133     updateItem(item, config);

   134 

   135     if (parent)

   136         parent->addChild(item);

   137     else

   138         treeWidget->addTopLevelItem(item);

   139 

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

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

   142             configurationAdded(child, item);

   143     }

   144 }

   145 

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

   147 {

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

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

   150 

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

   152             delete item;

   153             break;

   154         }

   155     }

   156 }

   157 

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

   159 {

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

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

   162 

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

   164             updateItem(item, config);

   165 

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

   167                 updateSnapConfiguration(item, config);

   168 

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

   170                 showConfigurationFor(item);

   171 

   172             break;

   173         }

   174     }

   175 }

   176 

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

   178 {

   179     QMap<QString, QTreeWidgetItem *> itemMap;

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

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

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

   183     }

   184 

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

   186 

   187     while (!allConfigurations.isEmpty()) {

   188         QNetworkConfiguration config = allConfigurations.takeFirst();

   189 

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

   191         if (item) {

   192             updateItem(item, config);

   193 

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

   195                 updateSnapConfiguration(item, config);

   196         } else {

   197             configurationAdded(config, parent);

   198         }

   199     }

   200 

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

   202         delete itemMap.value(id);

   203 

   204     itemMap.clear();

   205 }

   206 

   207 void BearerMonitor::updateConfigurations()

   208 {

   209     progressBar->hide();

   210     scanButton->show();

   211 

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

   213     QMap<QString, QTreeWidgetItem *> itemMap;

   214     while (!items.isEmpty()) {

   215         QTreeWidgetItem *item = items.takeFirst();

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

   217     }

   218 

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

   220 

   221     while (!allConfigurations.isEmpty()) {

   222         QNetworkConfiguration config = allConfigurations.takeFirst();

   223 

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

   225         if (item) {

   226             updateItem(item, config);

   227 

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

   229                 updateSnapConfiguration(item, config);

   230         } else {

   231             configurationAdded(config);

   232         }

   233     }

   234 

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

   236         delete itemMap.value(id);

   237 }

   238 

   239 void BearerMonitor::onlineStateChanged(bool isOnline)

   240 {

   241     if (isOnline)

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

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

   244     else

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

   246 #else

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

   248     else

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

   250 #endif

   251 }

   252 

   253 #ifdef Q_OS_WIN

   254 void BearerMonitor::registerNetwork()

   255 {

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

   257     if (!item) return;

   258 

   259     QNetworkConfiguration configuration =

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

   261 

   262     const QString name = configuration.name();

   263 

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

   265 

   266     WSAQUERYSET networkInfo;

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

   268     networkInfo.dwSize = sizeof(networkInfo);

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

   270     networkInfo.dwNameSpace = NS_NLA;

   271 

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

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

   274 }

   275 

   276 void BearerMonitor::unregisterNetwork()

   277 {

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

   279     if (!item) return;

   280 

   281     QNetworkConfiguration configuration =

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

   283 

   284     const QString name = configuration.name();

   285 

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

   287 

   288     WSAQUERYSET networkInfo;

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

   290     networkInfo.dwSize = sizeof(networkInfo);

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

   292     networkInfo.dwNameSpace = NS_NLA;

   293 

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

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

   296 }

   297 #endif

   298 

   299 void BearerMonitor::showConfigurationFor(QTreeWidgetItem *item)

   300 {

   301     QString identifier;

   302 

   303     if (item)

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

   305 

   306     QNetworkConfiguration conf = manager.configurationFromIdentifier(identifier);

   307 

   308     switch (conf.state()) {

   309     case QNetworkConfiguration::Active:

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

   311         break;

   312     case QNetworkConfiguration::Discovered:

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

   314         break;

   315     case QNetworkConfiguration::Defined:

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

   317         break;

   318     case QNetworkConfiguration::Undefined:

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

   320         break;

   321     default:

   322         configurationState->setText(QString());

   323     }

   324 

   325     switch (conf.type()) {

   326     case QNetworkConfiguration::InternetAccessPoint:

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

   328         break;

   329     case QNetworkConfiguration::ServiceNetwork:

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

   331         break;

   332     case QNetworkConfiguration::UserChoice:

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

   334         break;

   335     case QNetworkConfiguration::Invalid:

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

   337         break;

   338     default:

   339         configurationType->setText(QString());

   340     }

   341 

   342     switch (conf.purpose()) {

   343     case QNetworkConfiguration::UnknownPurpose:

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

   345         break;

   346     case QNetworkConfiguration::PublicPurpose:

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

   348         break;

   349     case QNetworkConfiguration::PrivatePurpose:

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

   351         break;

   352     case QNetworkConfiguration::ServiceSpecificPurpose:

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

   354         break;

   355     default:

   356         configurationPurpose->setText(QString());

   357     }

   358 

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

   360 

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

   362 

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

   364 

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

   366 }

   367 

   368 void BearerMonitor::createSessionFor(QTreeWidgetItem *item)

   369 {

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

   371 

   372     QNetworkConfiguration conf = manager.configurationFromIdentifier(identifier);

   373 

   374     SessionWidget *session = new SessionWidget(conf);

   375 

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

   377 

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

   379     sessionGroup->show();

   380 #endif

   381 

   382     sessionWidgets.append(session);

   383 }

   384 

   385 void BearerMonitor::createNewSession()

   386 {

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

   388     if (!item) return;

   389 

   390     createSessionFor(item);

   391 }

   392 

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

   394 void BearerMonitor::deleteSession()

   395 {

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

   397     if (session) {

   398         sessionWidgets.removeAll(session);

   399 

   400         delete session;

   401 

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

   403             sessionGroup->hide();

   404     }

   405 }

   406 #endif

   407 

   408 void BearerMonitor::performScan()

   409 {

   410     scanButton->hide();

   411     progressBar->show();

   412     manager.updateConfigurations();

   413 }