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

     2 **

     3 ** Copyright (C) 2009 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:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "bearerex.h"

    42 

    43 #include <QtNetwork>

    44 

    45 Q_DECLARE_METATYPE(QNetworkConfiguration)

    46 

    47 BearerEx::BearerEx(QWidget* parent)

    48      : QMainWindow(parent)

    49 {

    50     setupUi(this);

    51     

    52     createMenus();

    53     

    54     connect(&m_NetworkConfigurationManager, SIGNAL(updateCompleted()), this, SLOT(configurationsUpdateCompleted()));

    55     connect(&m_NetworkConfigurationManager, SIGNAL(configurationAdded(const QNetworkConfiguration&)),

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

    57     connect(&m_NetworkConfigurationManager, SIGNAL(configurationRemoved(const QNetworkConfiguration&)),

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

    59     connect(&m_NetworkConfigurationManager, SIGNAL(onlineStateChanged(bool)),

    60             this, SLOT(onlineStateChanged(bool)));

    61     connect(&m_NetworkConfigurationManager, SIGNAL(configurationChanged(const QNetworkConfiguration&)),

    62             this, SLOT(configurationChanged(const QNetworkConfiguration&)));

    63     showConfigurations();

    64 }

    65 

    66 void BearerEx::createMenus()

    67 {

    68     QAction* act1 = new QAction(tr("Show Details"), this);

    69     menuBar()->addAction(act1);

    70     connect(act1, SIGNAL(triggered()), this, SLOT(on_showDetailsButton_clicked()));

    71 

    72     QAction* exitAct = new QAction(tr("Exit"), this);

    73     menuBar()->addAction(exitAct);

    74     connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

    75 }

    76 

    77 void BearerEx::showConfigurations()

    78 {

    79     listWidget->clear();

    80     QListWidgetItem* listItem;

    81     

    82     QNetworkConfiguration defaultConfig = m_NetworkConfigurationManager.defaultConfiguration();

    83     if (defaultConfig.type() == QNetworkConfiguration::UserChoice) {

    84         listItem = new QListWidgetItem();

    85         QFont font = listItem->font();

    86         font.setBold(true);

    87         font.setUnderline(true);

    88         listItem->setFont(font);        

    89         listItem->setText("       UserChoice");

    90         listItem->setData(Qt::UserRole, qVariantFromValue(defaultConfig));

    91         listWidget->addItem(listItem);

    92     }

    93     

    94     QList<QNetworkConfiguration> configurations = m_NetworkConfigurationManager.allConfigurations();

    95     for (int i=0; i<configurations.count(); i++)

    96     {

    97         listItem = new QListWidgetItem();

    98         QString text;

    99         if (configurations[i].type() == QNetworkConfiguration::InternetAccessPoint) {

   100             text.append("(IAP,");

   101         } else if (configurations[i].type() == QNetworkConfiguration::ServiceNetwork) {

   102             text.append("(SNAP,");

   103         }

   104         

   105         if ((configurations[i].state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {

   106             text.append("Act) ");

   107         } else if ((configurations[i].state() & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered) {

   108             text.append("Disc) ");

   109         } else {

   110             text.append("Def) ");

   111         }

   112         text.append(configurations[i].name());

   113         

   114         if (defaultConfig.isValid() && defaultConfig == configurations[i]) {

   115             QFont font = listItem->font();

   116             font.setBold(true);

   117             font.setUnderline(true);

   118             listItem->setFont(font);        

   119         }

   120         listItem->setText(text);

   121         listItem->setData(Qt::UserRole, qVariantFromValue(configurations[i]));

   122         listWidget->addItem(listItem);

   123     }

   124 }

   125 

   126 void BearerEx::on_updateConfigurationsButton_clicked()

   127 {

   128     m_NetworkConfigurationManager.updateConfigurations();

   129 }

   130 

   131 void BearerEx::on_updateListButton_clicked()

   132 {

   133     showConfigurations();

   134 }

   135 

   136 void BearerEx::on_showDetailsButton_clicked()

   137 {

   138     QListWidgetItem* item = listWidget->currentItem();

   139     if (!item) {

   140         return;

   141     }

   142 

   143 	QNetworkConfiguration networkConfiguration = qVariantValue<QNetworkConfiguration>(item->data(Qt::UserRole));

   144 	DetailedInfoDialog infoDialog(&networkConfiguration,this);

   145 	infoDialog.exec();

   146 }

   147 

   148 void BearerEx::on_createSessionButton_clicked()

   149 {

   150     QListWidgetItem* item = listWidget->currentItem();

   151     if (!item) {

   152         return;

   153     }    

   154     QNetworkConfiguration networkConfiguration = qVariantValue<QNetworkConfiguration>(item->data(Qt::UserRole));

   155     int newTabIndex = mainTabWidget->count();

   156     SessionTab* newTab = new SessionTab(&networkConfiguration,&m_NetworkConfigurationManager,eventListWidget,newTabIndex-1);

   157     QString label = QString("S")+QString::number(newTabIndex-1);

   158     mainTabWidget->insertTab(newTabIndex,newTab,label);

   159     mainTabWidget->setCurrentIndex(newTabIndex);

   160 }

   161 

   162 void BearerEx::on_clearEventListButton_clicked()

   163 {

   164     eventListWidget->clear();

   165 }

   166 

   167 void BearerEx::configurationAdded(const QNetworkConfiguration& config)

   168 {

   169     QListWidgetItem* listItem = new QListWidgetItem();

   170     listItem->setText(QString("Added: ")+config.name());

   171     eventListWidget->addItem(listItem);

   172 }

   173 

   174 void BearerEx::configurationRemoved(const QNetworkConfiguration& config)

   175 {

   176     QListWidgetItem* listItem = new QListWidgetItem();

   177     listItem->setText(QString("Removed: ")+config.name());

   178     eventListWidget->addItem(listItem);

   179 }

   180 

   181 void BearerEx::onlineStateChanged(bool isOnline)

   182 {

   183     QListWidgetItem* listItem = new QListWidgetItem();

   184     QFont font = listItem->font();

   185     font.setBold(true);

   186     listItem->setFont(font);        

   187     if (isOnline) {

   188         listItem->setText(QString("> Online"));

   189     } else {

   190         listItem->setText(QString("< Offline"));

   191     }

   192     eventListWidget->addItem(listItem);

   193 }

   194 

   195 void BearerEx::configurationChanged(const QNetworkConfiguration & config)

   196 {

   197     QListWidgetItem* listItem = new QListWidgetItem();

   198     QString state;

   199     switch (config.state())

   200     {

   201         case QNetworkConfiguration::Undefined:

   202             state = "Undef : ";

   203             break;

   204         case QNetworkConfiguration::Defined:

   205             state = "Def : ";

   206             break;

   207         case QNetworkConfiguration::Discovered:

   208             state = "Disc : ";

   209             break;

   210         case QNetworkConfiguration::Active:

   211             state = "Act : ";

   212             break;

   213     }

   214     listItem->setText(state+config.name());

   215     eventListWidget->addItem(listItem);

   216 }

   217 

   218 void BearerEx::configurationsUpdateCompleted()

   219 {

   220     QMessageBox msgBox;

   221     msgBox.setStandardButtons(QMessageBox::Close);

   222     msgBox.setText("Configurations update completed.");

   223     msgBox.exec();

   224 }

   225 

   226 DetailedInfoDialog::DetailedInfoDialog(QNetworkConfiguration* apNetworkConfiguration, QWidget * parent)

   227     : QDialog(parent)

   228 {

   229     setupUi(this);

   230 

   231     tableWidget->setColumnCount(2);

   232     int rowCount = 2;

   233     

   234     if (apNetworkConfiguration->type() == QNetworkConfiguration::ServiceNetwork) {

   235         rowCount = rowCount + apNetworkConfiguration->children().count();

   236     }

   237 

   238 	tableWidget->setRowCount(rowCount);

   239 	tableWidget->setColumnWidth(1,250);

   240 	tableWidget->setItem(0, 0, new QTableWidgetItem(tr("Name")));

   241 	tableWidget->setItem(0, 1, new QTableWidgetItem(apNetworkConfiguration->name()));

   242 	tableWidget->setItem(1, 0, new QTableWidgetItem(tr("Id")));

   243 	tableWidget->setItem(1, 1, new QTableWidgetItem(apNetworkConfiguration->identifier()));

   244     if (apNetworkConfiguration->type() == QNetworkConfiguration::ServiceNetwork) {

   245         for (int i=0; i<apNetworkConfiguration->children().count(); i++) {

   246             tableWidget->setItem(i+2, 0, new QTableWidgetItem(QString("IAP")+QString::number(i+1)));

   247             tableWidget->setItem(i+2, 1, new QTableWidgetItem(apNetworkConfiguration->children()[i].name()));

   248         }

   249     }

   250     

   251     tableWidget->setFocusPolicy(Qt::NoFocus);

   252 

   253 #ifdef Q_OS_SYMBIAN

   254     this->showMaximized();

   255 #endif

   256 }

   257 

   258 SessionTab::SessionTab(QNetworkConfiguration* apNetworkConfiguration,

   259                        QNetworkConfigurationManager* configManager,

   260                        QListWidget* eventListWidget,

   261                        int index,

   262                        BearerEx * parent)

   263     : QWidget(parent), m_http(0), m_eventListWidget(eventListWidget),

   264      m_index(index), m_httpRequestOngoing(false), m_alrEnabled (false)

   265 {

   266     setupUi(this);

   267 

   268     m_ConfigManager = configManager;

   269     m_NetworkSession = new QNetworkSession(*apNetworkConfiguration);

   270 

   271     // Update initial Session state to UI

   272     newState(m_NetworkSession->state());

   273 

   274     connect(m_NetworkSession, SIGNAL(newConfigurationActivated()), this, SLOT(newConfigurationActivated()));

   275     connect(m_NetworkSession, SIGNAL(stateChanged(QNetworkSession::State)),

   276             this, SLOT(stateChanged(QNetworkSession::State)));

   277     connect(m_NetworkSession, SIGNAL(opened()), this, SLOT(opened()));

   278     connect(m_NetworkSession, SIGNAL(closed()), this, SLOT(closed()));

   279     connect(m_NetworkSession, SIGNAL(error(QNetworkSession::SessionError)), this, SLOT(error(QNetworkSession::SessionError)));

   280     

   281     if (apNetworkConfiguration->type() == QNetworkConfiguration::InternetAccessPoint) {

   282         snapLabel->hide();

   283         snapLineEdit->hide();

   284         alrButton->hide();

   285         iapLineEdit->setText(apNetworkConfiguration->name()+" ("+apNetworkConfiguration->identifier()+")");

   286     } else if (apNetworkConfiguration->type() == QNetworkConfiguration::ServiceNetwork) {

   287         snapLineEdit->setText(apNetworkConfiguration->name()+" ("+apNetworkConfiguration->identifier()+")");

   288     }

   289     bearerLineEdit->setText(apNetworkConfiguration->bearerName());

   290     sentRecDataLineEdit->setText(QString::number(m_NetworkSession->bytesWritten())+

   291                                  QString(" / ")+

   292                                  QString::number(m_NetworkSession->bytesReceived()));

   293     snapLineEdit->setFocusPolicy(Qt::NoFocus);

   294     iapLineEdit->setFocusPolicy(Qt::NoFocus);

   295     bearerLineEdit->setFocusPolicy(Qt::NoFocus);

   296     sentRecDataLineEdit->setFocusPolicy(Qt::NoFocus);

   297     stateLineEdit->setFocusPolicy(Qt::NoFocus);

   298 }

   299 

   300 SessionTab::~SessionTab()

   301 {

   302     delete m_NetworkSession;

   303     delete m_http;

   304 }

   305 

   306 void SessionTab::on_createQHttpButton_clicked()

   307 {

   308     if (m_httpRequestOngoing) {

   309         return;

   310     }

   311 

   312     if (m_http) {

   313         disconnect(m_http, 0, 0, 0);

   314         delete m_http;

   315     }

   316     m_http = new QHttp(this);

   317     createQHttpButton->setText("Recreate QHttp");

   318     connect(m_http, SIGNAL(done(bool)), this, SLOT(done(bool)));    

   319 }

   320 

   321 void SessionTab::on_sendRequestButton_clicked()

   322 {

   323     if (m_http) {

   324         QString urlstring("http://www.google.com");

   325         QUrl url(urlstring);

   326         m_http->setHost(url.host(), QHttp::ConnectionModeHttp, url.port() == -1 ? 0 : url.port());

   327         m_http->get(urlstring);

   328         m_httpRequestOngoing = true;

   329     } else {

   330         QMessageBox msgBox;

   331         msgBox.setStandardButtons(QMessageBox::Close);

   332         msgBox.setText("QHttp not created.\nCreate QHttp First.");

   333         msgBox.exec();

   334     }

   335 }

   336 

   337 void SessionTab::on_openSessionButton_clicked()

   338 {

   339     m_NetworkSession->open();

   340     if (m_NetworkSession->isOpen()) {

   341         newState(m_NetworkSession->state()); 

   342     }

   343 }

   344 

   345 void SessionTab::on_closeSessionButton_clicked()

   346 {

   347     m_NetworkSession->close();

   348     if (!m_NetworkSession->isOpen()) {

   349         newState(m_NetworkSession->state()); 

   350     }

   351 }

   352 

   353 void SessionTab::on_stopConnectionButton_clicked()

   354 {

   355     m_NetworkSession->stop();

   356 }

   357 

   358 void SessionTab::on_alrButton_clicked()

   359 {

   360     if (!m_alrEnabled) {

   361         connect(m_NetworkSession, SIGNAL(preferredConfigurationChanged(const QNetworkConfiguration&, bool)),

   362                 this, SLOT(preferredConfigurationChanged(const QNetworkConfiguration&, bool)));

   363         alrButton->setText("Disable ALR");

   364         m_alrEnabled = true;

   365     } else {

   366         disconnect(m_NetworkSession, SIGNAL(preferredConfigurationChanged(const QNetworkConfiguration&, bool)), 0, 0);

   367         alrButton->setText("Enable ALR");

   368         m_alrEnabled = false;

   369     }

   370 }

   371 

   372 void SessionTab::on_deleteSessionButton_clicked()

   373 {

   374     setWindowTitle("Bearer Example");

   375     delete this;

   376 }

   377 

   378 void SessionTab::newConfigurationActivated()

   379 {

   380     QMessageBox msgBox;

   381     msgBox.setText("New configuration activated.");

   382     msgBox.setInformativeText("Do you want to accept new configuration?");

   383     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

   384     msgBox.setDefaultButton(QMessageBox::Yes);

   385     if (msgBox.exec() == QMessageBox::Yes) {

   386         m_NetworkSession->accept();

   387         iapLineEdit->setText(m_config.name()+" ("+m_config.identifier()+")");

   388     } else {

   389         m_NetworkSession->reject();

   390     }

   391 }

   392 

   393 void SessionTab::preferredConfigurationChanged(const QNetworkConfiguration& config, bool /*isSeamless*/)

   394 {

   395     m_config =  config;

   396     QMessageBox msgBox;

   397     msgBox.setText("Roaming to new configuration.");

   398     msgBox.setInformativeText("Do you want to migrate to "+config.name()+"?");

   399     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

   400     msgBox.setDefaultButton(QMessageBox::Yes);

   401     if (msgBox.exec() == QMessageBox::Yes) {

   402         m_NetworkSession->migrate();

   403     } else {

   404         m_NetworkSession->ignore();

   405     }

   406 }

   407 

   408 void SessionTab::opened()

   409 {

   410     QListWidgetItem* listItem = new QListWidgetItem();

   411     QFont font = listItem->font();

   412     font.setBold(true);

   413     listItem->setFont(font);        

   414     listItem->setText(QString("S")+QString::number(m_index)+QString(" - ")+QString("Opened"));

   415     m_eventListWidget->addItem(listItem);

   416     

   417     QVariant identifier = m_NetworkSession->property("ActiveConfiguration");

   418     if (!identifier.isNull()) {

   419         QString configId = identifier.toString();

   420         QNetworkConfiguration config = m_ConfigManager->configurationFromIdentifier(configId);

   421         if (config.isValid()) {

   422             iapLineEdit->setText(config.name()+" ("+config.identifier()+")");

   423         }

   424     }

   425 

   426     if (m_NetworkSession->configuration().type() == QNetworkConfiguration::UserChoice) {

   427         QVariant identifier = m_NetworkSession->property("UserChoiceConfiguration");

   428         if (!identifier.isNull()) {

   429             QString configId = identifier.toString();

   430             QNetworkConfiguration config = m_ConfigManager->configurationFromIdentifier(configId);

   431             if (config.isValid() && (config.type() == QNetworkConfiguration::ServiceNetwork)) {

   432                 snapLineEdit->setText(config.name());

   433             }

   434         }

   435     }

   436 }

   437 

   438 void SessionTab::closed()

   439 {

   440     QListWidgetItem* listItem = new QListWidgetItem();

   441     QFont font = listItem->font();

   442     font.setBold(true);

   443     listItem->setFont(font);        

   444     listItem->setText(QString("S")+QString::number(m_index)+QString(" - ")+QString("Closed"));

   445     m_eventListWidget->addItem(listItem);

   446 }

   447 

   448 QString SessionTab::stateString(QNetworkSession::State state)

   449 {

   450     QString stateString;

   451     switch (state)

   452     {

   453         case QNetworkSession::Invalid:

   454             stateString = "Invalid";

   455             break;

   456         case QNetworkSession::NotAvailable:

   457             stateString = "NotAvailable";

   458             break;

   459         case QNetworkSession::Connecting:

   460             stateString = "Connecting";

   461             break;

   462         case QNetworkSession::Connected:

   463             stateString = "Connected";

   464             break;

   465         case QNetworkSession::Closing:

   466             stateString = "Closing";

   467             break;

   468         case QNetworkSession::Disconnected:

   469             stateString = "Disconnected";

   470             break;

   471         case QNetworkSession::Roaming:

   472             stateString = "Roaming";

   473             break;

   474     }

   475     return stateString;

   476 }

   477 

   478 void SessionTab::stateChanged(QNetworkSession::State state)    

   479 {

   480     newState(state);

   481     

   482     QListWidgetItem* listItem = new QListWidgetItem();

   483     listItem->setText(QString("S")+QString::number(m_index)+QString(" - ")+stateString(state));

   484     m_eventListWidget->addItem(listItem);

   485 }

   486 

   487 void SessionTab::newState(QNetworkSession::State state)

   488 {

   489     QVariant identifier = m_NetworkSession->property("ActiveConfiguration");

   490     if (state == QNetworkSession::Connected && !identifier.isNull()) {

   491         QString configId = identifier.toString();

   492         QNetworkConfiguration config = m_ConfigManager->configurationFromIdentifier(configId);

   493         if (config.isValid()) {

   494             iapLineEdit->setText(config.name()+" ("+config.identifier()+")");

   495             bearerLineEdit->setText(config.bearerName());

   496         }

   497     } else {

   498         bearerLineEdit->setText(m_NetworkSession->configuration().bearerName());

   499     }

   500 

   501     QString active;

   502     if (m_NetworkSession->isOpen()) {

   503         active = " (O)";

   504     }

   505     stateLineEdit->setText(stateString(state)+active);

   506 }

   507 

   508 void SessionTab::error(QNetworkSession::SessionError error)

   509 {

   510     QListWidgetItem* listItem = new QListWidgetItem();

   511     QMessageBox msgBox;

   512     msgBox.setStandardButtons(QMessageBox::Close);

   513     

   514     QString errorString;

   515     switch (error)

   516     {

   517         case QNetworkSession::UnknownSessionError:

   518             errorString = "UnknownSessionError";

   519             break;

   520         case QNetworkSession::SessionAbortedError:

   521             errorString = "SessionAbortedError";

   522             break;

   523         case QNetworkSession::RoamingError:

   524             errorString = "RoamingError";

   525             break;

   526         case QNetworkSession::OperationNotSupportedError:

   527             errorString = "OperationNotSupportedError";

   528             break;

   529         case QNetworkSession::InvalidConfigurationError:

   530             errorString = "InvalidConfigurationError";

   531             break;

   532     }

   533     listItem->setText(QString("S")+QString::number(m_index)+QString(" - ")+errorString);

   534     m_eventListWidget->addItem(listItem);

   535     

   536     msgBox.setText(errorString);

   537     msgBox.exec();

   538 }

   539 

   540 void SessionTab::done(bool error)

   541 {

   542     m_httpRequestOngoing = false;

   543 

   544     QMessageBox msgBox;

   545     msgBox.setStandardButtons(QMessageBox::Close);

   546     if (error) {

   547         msgBox.setText("HTTP request failed.");

   548     } else {

   549         QString result(m_http->readAll());

   550         msgBox.setText(QString("HTTP request finished successfully.\nReceived ")+QString::number(result.length())+QString(" bytes."));

   551     }

   552     msgBox.exec();

   553     

   554     sentRecDataLineEdit->setText(QString::number(m_NetworkSession->bytesWritten())+

   555                                  QString(" / ")+

   556                                  QString::number(m_NetworkSession->bytesReceived()));

   557 }

   558 

   559 // End of file

   560