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: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 #include "datatransferer.h"

    43 

    44 #include <QtNetwork>

    45 

    46 Q_DECLARE_METATYPE(QNetworkConfiguration)

    47 

    48 BearerEx::BearerEx(QWidget* parent)

    49      : QMainWindow(parent)

    50 {

    51     setupUi(this);

    52     

    53     createMenus();

    54     

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

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

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

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

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

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

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

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

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

    64     showConfigurations();

    65 }

    66 

    67 void BearerEx::createMenus()

    68 {

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

    70     menuBar()->addAction(act1);

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

    72 

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

    74     menuBar()->addAction(exitAct);

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

    76 }

    77 

    78 void BearerEx::showConfigurations()

    79 {

    80     listWidget->clear();

    81     QListWidgetItem* listItem;

    82     

    83     QNetworkConfiguration defaultConfig = m_NetworkConfigurationManager.defaultConfiguration();

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

    85         listItem = new QListWidgetItem();

    86         QFont font = listItem->font();

    87         font.setBold(true);

    88         font.setUnderline(true);

    89         listItem->setFont(font);        

    90         listItem->setText("       UserChoice");

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

    92         listWidget->addItem(listItem);

    93     }

    94     

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

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

    97     {

    98         listItem = new QListWidgetItem();

    99         QString text;

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

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

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

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

   104         }

   105         

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

   107             text.append("Act) ");

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

   109             text.append("Disc) ");

   110         } else {

   111             text.append("Def) ");

   112         }

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

   114         

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

   116             QFont font = listItem->font();

   117             font.setBold(true);

   118             font.setUnderline(true);

   119             listItem->setFont(font);        

   120         }

   121         listItem->setText(text);

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

   123         listWidget->addItem(listItem);

   124     }

   125 }

   126 

   127 void BearerEx::on_updateConfigurationsButton_clicked()

   128 {

   129     m_NetworkConfigurationManager.updateConfigurations();

   130 }

   131 

   132 void BearerEx::on_updateListButton_clicked()

   133 {

   134     showConfigurations();

   135 }

   136 

   137 void BearerEx::on_showDetailsButton_clicked()

   138 {

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

   140     if (!item) {

   141         return;

   142     }

   143 

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

   145 	DetailedInfoDialog infoDialog(&networkConfiguration,this);

   146 	infoDialog.exec();

   147 }

   148 

   149 void BearerEx::on_createSessionButton_clicked()

   150 {

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

   152     if (!item) {

   153         return;

   154     }    

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

   156     int newTabIndex = mainTabWidget->count();

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

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

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

   160     mainTabWidget->setCurrentIndex(newTabIndex);

   161 }

   162 

   163 void BearerEx::on_clearEventListButton_clicked()

   164 {

   165     eventListWidget->clear();

   166 }

   167 

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

   169 {

   170     QListWidgetItem* listItem = new QListWidgetItem();

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

   172     eventListWidget->addItem(listItem);

   173 }

   174 

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

   176 {

   177     QListWidgetItem* listItem = new QListWidgetItem();

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

   179     eventListWidget->addItem(listItem);

   180 }

   181 

   182 void BearerEx::onlineStateChanged(bool isOnline)

   183 {

   184     QListWidgetItem* listItem = new QListWidgetItem();

   185     QFont font = listItem->font();

   186     font.setBold(true);

   187     listItem->setFont(font);        

   188     if (isOnline) {

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

   190     } else {

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

   192     }

   193     eventListWidget->addItem(listItem);

   194 }

   195 

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

   197 {

   198     QListWidgetItem* listItem = new QListWidgetItem();

   199     QString state;

   200     switch (config.state())

   201     {

   202         case QNetworkConfiguration::Undefined:

   203             state = "Undef : ";

   204             break;

   205         case QNetworkConfiguration::Defined:

   206             state = "Def : ";

   207             break;

   208         case QNetworkConfiguration::Discovered:

   209             state = "Disc : ";

   210             break;

   211         case QNetworkConfiguration::Active:

   212             state = "Act : ";

   213             break;

   214     }

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

   216     eventListWidget->addItem(listItem);

   217 }

   218 

   219 void BearerEx::configurationsUpdateCompleted()

   220 {

   221     QMessageBox msgBox;

   222     msgBox.setStandardButtons(QMessageBox::Close);

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

   224     msgBox.exec();

   225 }

   226 

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

   228     : QDialog(parent)

   229 {

   230     setupUi(this);

   231 

   232     tableWidget->setColumnCount(2);

   233     int rowCount = 2;

   234     

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

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

   237     }

   238 

   239 	tableWidget->setRowCount(rowCount);

   240 	tableWidget->setColumnWidth(1,250);

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

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

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

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

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

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

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

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

   249         }

   250     }

   251     

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

   253 

   254 #ifdef Q_OS_SYMBIAN

   255     this->showMaximized();

   256 #endif

   257 }

   258 

   259 SessionTab::SessionTab(QNetworkConfiguration* apNetworkConfiguration,

   260                        QNetworkConfigurationManager* configManager,

   261                        QListWidget* eventListWidget,

   262                        int index,

   263                        BearerEx * parent)

   264     : QWidget(parent), m_dataTransferer(0), m_eventListWidget(eventListWidget),

   265      m_index(index), m_alrEnabled (false)

   266 {

   267     setupUi(this);

   268 

   269     m_ConfigManager = configManager;

   270     m_NetworkSession = new QNetworkSession(*apNetworkConfiguration);

   271 

   272     // Update initial Session state to UI

   273     newState(m_NetworkSession->state());

   274 

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

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

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

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

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

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

   281     

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

   283         snapLabel->hide();

   284         snapLineEdit->hide();

   285         alrButton->hide();

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

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

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

   289     }

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

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

   292                                  QString(" / ")+

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

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

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

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

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

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

   299 }

   300 

   301 SessionTab::~SessionTab()

   302 {

   303     delete m_NetworkSession; m_NetworkSession = 0;

   304     delete m_dataTransferer; m_dataTransferer = 0;

   305 }

   306 

   307 void SessionTab::on_createQNetworkAccessManagerButton_clicked()

   308 {

   309     if (m_dataTransferer) {

   310         disconnect(m_dataTransferer, 0, 0, 0);

   311         delete m_dataTransferer;

   312         m_dataTransferer = 0;

   313     }

   314     // Create new object according to current selection

   315     QString type(comboBox->currentText());

   316     if (type == "QNAM") {

   317         m_dataTransferer = new DataTransfererQNam(this);

   318     } else if (type == "QTcpSocket") {

   319         m_dataTransferer = new DataTransfererQTcp(this);

   320     } else if (type == "QHttp") {

   321         m_dataTransferer = new DataTransfererQHttp(this);

   322     } else {

   323         qDebug("BearerEx Warning, unknown data transfer object requested, not creating anything.");

   324         return;

   325     }

   326     createQNetworkAccessManagerButton->setText("Recreate");

   327     connect(m_dataTransferer, SIGNAL(finished(quint32, qint64, QString)), this, SLOT(finished(quint32, qint64, QString)));

   328 }

   329 

   330 void SessionTab::on_sendRequestButton_clicked()

   331 {

   332     if (m_dataTransferer) {

   333         if (!m_dataTransferer->transferData()) {

   334             QMessageBox msgBox;

   335             msgBox.setStandardButtons(QMessageBox::Close);

   336             msgBox.setText("Data transfer not started. \nVery likely data transfer ongoing.");

   337             msgBox.exec();

   338         }

   339     } else {

   340         QMessageBox msgBox;

   341         msgBox.setStandardButtons(QMessageBox::Close);

   342         msgBox.setText("Data object not created.\nCreate data object first.");

   343         msgBox.exec();

   344     }

   345 }

   346 

   347 void SessionTab::on_openSessionButton_clicked()

   348 {

   349     m_NetworkSession->open();

   350     if (m_NetworkSession->isOpen()) {

   351         newState(m_NetworkSession->state()); 

   352     }

   353 }

   354 

   355 void SessionTab::on_closeSessionButton_clicked()

   356 {

   357     m_NetworkSession->close();

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

   359         newState(m_NetworkSession->state()); 

   360     }

   361 }

   362 

   363 void SessionTab::on_stopConnectionButton_clicked()

   364 {

   365     m_NetworkSession->stop();

   366 }

   367 

   368 void SessionTab::on_alrButton_clicked()

   369 {

   370     if (!m_alrEnabled) {

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

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

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

   374         m_alrEnabled = true;

   375     } else {

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

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

   378         m_alrEnabled = false;

   379     }

   380 }

   381 

   382 void SessionTab::on_deleteSessionButton_clicked()

   383 {

   384     setWindowTitle("Bearer Example");

   385     delete this;

   386 }

   387 

   388 void SessionTab::newConfigurationActivated()

   389 {

   390     QMessageBox msgBox;

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

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

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

   394     msgBox.setDefaultButton(QMessageBox::Yes);

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

   396         m_NetworkSession->accept();

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

   398     } else {

   399         m_NetworkSession->reject();

   400     }

   401 }

   402 

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

   404 {

   405     m_config =  config;

   406     QMessageBox msgBox;

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

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

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

   410     msgBox.setDefaultButton(QMessageBox::Yes);

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

   412         m_NetworkSession->migrate();

   413     } else {

   414         m_NetworkSession->ignore();

   415     }

   416 }

   417 

   418 void SessionTab::opened()

   419 {

   420     QListWidgetItem* listItem = new QListWidgetItem();

   421     QFont font = listItem->font();

   422     font.setBold(true);

   423     listItem->setFont(font);        

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

   425     m_eventListWidget->addItem(listItem);

   426     

   427     QVariant identifier = m_NetworkSession->sessionProperty("ActiveConfiguration");

   428     if (!identifier.isNull()) {

   429         QString configId = identifier.toString();

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

   431         if (config.isValid()) {

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

   433         }

   434     }

   435     newState(m_NetworkSession->state()); // Update the "(open)"

   436 

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

   438         QVariant identifier = m_NetworkSession->sessionProperty("UserChoiceConfiguration");

   439         if (!identifier.isNull()) {

   440             QString configId = identifier.toString();

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

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

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

   444             }

   445         }

   446     }

   447 }

   448 

   449 void SessionTab::closed()

   450 {

   451     QListWidgetItem* listItem = new QListWidgetItem();

   452     QFont font = listItem->font();

   453     font.setBold(true);

   454     listItem->setFont(font);        

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

   456     m_eventListWidget->addItem(listItem);

   457 }

   458 

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

   460 {

   461     QString stateString;

   462     switch (state)

   463     {

   464         case QNetworkSession::Invalid:

   465             stateString = "Invalid";

   466             break;

   467         case QNetworkSession::NotAvailable:

   468             stateString = "NotAvailable";

   469             break;

   470         case QNetworkSession::Connecting:

   471             stateString = "Connecting";

   472             break;

   473         case QNetworkSession::Connected:

   474             stateString = "Connected";

   475             break;

   476         case QNetworkSession::Closing:

   477             stateString = "Closing";

   478             break;

   479         case QNetworkSession::Disconnected:

   480             stateString = "Disconnected";

   481             break;

   482         case QNetworkSession::Roaming:

   483             stateString = "Roaming";

   484             break;

   485     }

   486     return stateString;

   487 }

   488 

   489 void SessionTab::on_dataObjectChanged(const QString &newObjectType)

   490 {

   491     qDebug() << "BearerEx SessionTab dataObjectChanged to: " << newObjectType;

   492     if (m_dataTransferer) {

   493         disconnect(m_dataTransferer, 0, 0, 0);

   494         delete m_dataTransferer; m_dataTransferer = 0;

   495         qDebug() << "BearerEx SessionTab, previous data object deleted.";

   496     }

   497     createQNetworkAccessManagerButton->setText("Create");

   498 }

   499 

   500 

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

   502 {

   503     newState(state);

   504     

   505     QListWidgetItem* listItem = new QListWidgetItem();

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

   507     m_eventListWidget->addItem(listItem);

   508 }

   509 

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

   511 {

   512     QVariant identifier = m_NetworkSession->sessionProperty("ActiveConfiguration");

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

   514         QString configId = identifier.toString();

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

   516         if (config.isValid()) {

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

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

   519         }

   520     } else {

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

   522     }

   523 

   524     QString active;

   525     if (m_NetworkSession->isOpen()) {

   526         active = " (open)";

   527     }

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

   529 }

   530 

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

   532 {

   533     QListWidgetItem* listItem = new QListWidgetItem();

   534     QMessageBox msgBox;

   535     msgBox.setStandardButtons(QMessageBox::Close);

   536     

   537     QString errorString;

   538     switch (error)

   539     {

   540         case QNetworkSession::UnknownSessionError:

   541             errorString = "UnknownSessionError";

   542             break;

   543         case QNetworkSession::SessionAbortedError:

   544             errorString = "SessionAbortedError";

   545             break;

   546         case QNetworkSession::RoamingError:

   547             errorString = "RoamingError";

   548             break;

   549         case QNetworkSession::OperationNotSupportedError:

   550             errorString = "OperationNotSupportedError";

   551             break;

   552         case QNetworkSession::InvalidConfigurationError:

   553             errorString = "InvalidConfigurationError";

   554             break;

   555     }

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

   557     m_eventListWidget->addItem(listItem);

   558     

   559     msgBox.setText(errorString);

   560     msgBox.exec();

   561 }

   562 

   563 void SessionTab::finished(quint32 errorCode, qint64 dataReceived, QString errorType)

   564 {

   565     QMessageBox msgBox;

   566     msgBox.setStandardButtons(QMessageBox::Close);

   567     msgBox.setText(QString("Data transfer completed. \nError code: ") + QString::number((int)errorCode) +

   568                    "\nError type: " + errorType +

   569                    "\nBytes received: " +

   570                    QString::number(dataReceived));

   571     msgBox.exec();

   572     // Check if the networksession still exists - it may have gone after returning from

   573     // the modal dialog (in the case that app has been closed, and deleting QHttp will

   574     // trigger the done() invokation).

   575     if (m_NetworkSession) {

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

   577                                      QString(" / ")+

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

   579     } else {

   580         sentRecDataLineEdit->setText("Data amounts not available.");

   581     }

   582 }

   583 

   584 // End of file

   585