1 /**

     2    This file is part of CWRT package **

     3 

     4    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). **

     5 

     6    This program is free software: you can redistribute it and/or modify

     7    it under the terms of the GNU (Lesser) General Public License as

     8    published by the Free Software Foundation, version 2.1 of the License.

     9    This program is distributed in the hope that it will be useful, but

    10    WITHOUT ANY WARRANTY; without even the implied warranty of

    11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

    12    (Lesser) General Public License for more details. You should have

    13    received a copy of the GNU (Lesser) General Public License along

    14    with this program. If not, see <http://www.gnu.org/licenses/>.

    15 */

    16 

    17 #include "downloadmanagerclient.h"

    18 #include "backgrounddownloadmanager.h"

    19 #include "backgrounddownload.h"

    20 #include <serviceipc.h>

    21 #include <QTimer>

    22 #include <QtNetwork>

    23 

    24 class DownloadManagerClientPrivate

    25 {

    26     DM_DECLARE_PUBLIC(DownloadManagerClient);

    27 public:

    28     DownloadManagerClientPrivate();

    29     ~DownloadManagerClientPrivate();

    30     QString m_clientName;

    31     bool m_isConnected;

    32     int m_error;

    33     WRT::ServiceFwIPC* m_session;

    34     DownloadManager* m_downloadManager;

    35     QTimer* m_timer;

    36 };

    37 

    38 DownloadManagerClientPrivate::DownloadManagerClientPrivate()

    39 {

    40     m_clientName = "";

    41     m_isConnected = false;

    42     m_error = 0;

    43     m_session = 0;

    44     m_downloadManager = 0;

    45     m_timer = 0;

    46 }

    47 

    48 DownloadManagerClientPrivate::~DownloadManagerClientPrivate()

    49 {

    50     if (m_timer) {

    51         if (m_timer->isActive())

    52             m_timer->stop();

    53         delete m_timer;

    54         m_timer = 0;

    55     }

    56 

    57     if (m_session) {

    58         m_session->disconnect();

    59         delete m_session;

    60         m_session = 0;

    61     }

    62 }

    63 

    64 DownloadManagerClient::DownloadManagerClient(DownloadManager* downloadManager)

    65 {

    66     DM_INITIALIZE(DownloadManagerClient);

    67     priv->m_downloadManager = downloadManager;

    68     priv->m_timer = new QTimer;

    69     priv->m_clientName = downloadManager->getAttribute(DlMgrClientName).toString();

    70     priv->m_session = new WRT::ServiceFwIPC(this);

    71     connect(priv->m_session, SIGNAL(error(int aError)), this, SLOT(setServerError(int error)));

    72     connect(priv->m_timer, SIGNAL(timeout()), this, SLOT(getEvents()));

    73 

    74     // establish communication with server

    75     initServer();

    76 }

    77 

    78 DownloadManagerClient::~DownloadManagerClient()

    79 {

    80     DM_UNINITIALIZE(DownloadManagerClient);

    81 }

    82 

    83 bool DownloadManagerClient::initServer()

    84 {

    85     DM_PRIVATE(DownloadManagerClient);

    86 

    87     // start server (if required) and connect to it

    88     connectToServer();

    89 

    90     if (priv->m_isConnected) {

    91         // set startup details - proxy, download path, progress mode

    92         // and attach to downloads

    93         setStartupInfo();

    94 

    95         // start timer to get events from server

    96         priv->m_timer->start(EVENTS_REQUEST_INTERVAL);

    97         priv->m_downloadManager->postEvent(ConnectedToServer, NULL);

    98     }

    99 

   100     return priv->m_isConnected;

   101 }

   102 

   103 bool DownloadManagerClient::connectToServer()

   104 {

   105     DM_PRIVATE(DownloadManagerClient);

   106     if (priv->m_session) {

   107         int retry(2);

   108         for (;;)

   109         {

   110             priv->m_isConnected = priv->m_session->connect(DMSERVER);

   111             if (priv->m_isConnected) {

   112                 break;

   113             }

   114             else {

   115                 if (!priv->m_session->startServer(DMSERVER, DMSERVEREXE)) {

   116                     // start server failed.

   117                     break;

   118                 }

   119             }

   120             if (0==--retry) {

   121                 break;

   122             }

   123         }

   124     }

   125     if (!priv->m_isConnected) {

   126         delete priv->m_session;

   127         priv->m_session = 0;

   128     }

   129 

   130     return priv->m_isConnected;

   131 }

   132 

   133 void DownloadManagerClient::setStartupInfo()

   134 {

   135     DM_PRIVATE(DownloadManagerClient);

   136     if (!priv->m_isConnected)

   137         return;

   138 

   139     if (priv->m_downloadManager) {

   140         // get data from download manager

   141         QNetworkProxy* proxy = priv->m_downloadManager->proxy();

   142         QString dlPath = priv->m_downloadManager->getAttribute(DlMgrDestPath).toString();

   143         int progressMode = priv->m_downloadManager->getAttribute(DlMgrProgressMode).toInt();

   144         int persistantMode = priv->m_downloadManager->getAttribute(DlMgrPersistantMode).toInt();

   145         QString data;

   146 

   147         // client name

   148         data.append(encodeString(priv->m_clientName));

   149 

   150         // proxy info

   151         if (proxy) {

   152             data.append(DM_MSG_DELIMITER);

   153             data.append(QString::number(SetProxy));

   154             data.append(DM_FIELD_DELIMITER);

   155             data.append(encodeString(proxy->hostName()));

   156             data.append(DM_FIELD_DELIMITER);

   157             data.append(QString::number(proxy->port()));

   158         }

   159 

   160         // download path

   161         data.append(DM_MSG_DELIMITER);

   162         data.append(QString::number(SetDownloadManagerAttribute));

   163         data.append(DM_FIELD_DELIMITER);

   164         data.append(QString::number(DlMgrDestPath));

   165         data.append(DM_FIELD_DELIMITER);

   166         data.append(encodeString(dlPath));

   167 

   168         // progress mode (quiet/non-quiet)

   169         data.append(DM_MSG_DELIMITER);

   170         data.append(QString::number(SetDownloadManagerAttribute));

   171         data.append(DM_FIELD_DELIMITER);

   172         data.append(QString::number(DlMgrProgressMode));

   173         data.append(DM_FIELD_DELIMITER);

   174         data.append(encodeString(QString::number(progressMode)));

   175 

   176         // persistant mode (active / inactive)

   177         data.append(DM_MSG_DELIMITER);

   178         data.append(QString::number(SetDownloadManagerAttribute));

   179         data.append(DM_FIELD_DELIMITER);

   180         data.append(QString::number(DlMgrPersistantMode));

   181         data.append(DM_FIELD_DELIMITER);

   182         data.append(encodeString(QString::number(persistantMode)));

   183 

   184         // send to sever

   185         if (priv->m_session->sendSync(QString::number(StartupInfo), data.toAscii()))

   186             priv->m_session->readAll();

   187     }

   188 }

   189 

   190 void DownloadManagerClient::setProxy(const QString& proxyServer, const int port)

   191 {

   192     DM_PRIVATE(DownloadManagerClient);

   193     if (!priv->m_isConnected) {

   194         if (!initServer())

   195             return;

   196     }

   197 

   198     // create string to send

   199     QString data;

   200     data.append(encodeString(priv->m_clientName));

   201     data.append(DM_FIELD_DELIMITER);

   202     data.append(encodeString(proxyServer));

   203     data.append(DM_FIELD_DELIMITER);

   204     data.append(QString::number(port));

   205 

   206     // send to sever

   207     if (priv->m_session->sendSync(QString::number(SetProxy), data.toAscii()))

   208         priv->m_session->readAll();

   209     else

   210         setServerError(WRT::ServiceFwIPC::EIPCError);

   211 }

   212 

   213 int DownloadManagerClient::createDownload(const QString& url, DownloadType type)

   214 {

   215     DM_PRIVATE(DownloadManagerClient);

   216     int downloadId(INVALID_DL_ID);

   217     if (!priv->m_isConnected) {

   218         if (!initServer())

   219             return downloadId;

   220     }

   221 

   222     // create string to send

   223     QString data;

   224     data.append(encodeString(priv->m_clientName));

   225     data.append(DM_FIELD_DELIMITER);

   226     data.append(encodeString(url));

   227     data.append(DM_FIELD_DELIMITER);

   228     data.append(QString::number(type));

   229 

   230     // send to sever

   231     if (priv->m_session->sendSync(QString::number(CreateDownload), data.toAscii())) {

   232         // expected response is

   233         // list[0] -> downloadId

   234         QByteArray bytes = priv->m_session->readAll();

   235         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   236         if (list.count() == 1)

   237             downloadId = list[0].toInt();

   238     }

   239     else {

   240         setServerError(WRT::ServiceFwIPC::EIPCError);

   241     }

   242     return downloadId;

   243 }

   244 

   245 bool DownloadManagerClient::attachToDownload(int dlId)

   246 {

   247     DM_PRIVATE(DownloadManagerClient);

   248     bool status(false);

   249     if (!priv->m_isConnected) {

   250         if (!initServer())

   251             return status;

   252     }

   253 

   254     // create string to send

   255     QString data;

   256     data.append(encodeString(priv->m_clientName));

   257     data.append(DM_FIELD_DELIMITER);

   258     data.append(QString::number(dlId));

   259 

   260     // send to sever

   261     if (priv->m_session->sendSync(QString::number(AttachToDownload), data.toAscii())) {

   262         // expected response is

   263 	// list[1] -> status

   264         QByteArray bytes = priv->m_session->readAll();

   265         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   266         if (list.count() == 1) {

   267             status = list[0].toInt();

   268 	}

   269     }

   270     else {

   271         setServerError(WRT::ServiceFwIPC::EIPCError);

   272     }

   273 	

   274     return status;

   275 }

   276 

   277 void DownloadManagerClient::removeDownload(int downloadId)

   278 {

   279     DM_PRIVATE(DownloadManagerClient);

   280     if (!priv->m_isConnected) {

   281         if (!initServer())

   282             return;

   283     }

   284 

   285     // create string to send

   286     QString data;

   287     data.append(encodeString(priv->m_clientName));

   288     data.append(DM_FIELD_DELIMITER);

   289     data.append(QString::number(downloadId));

   290 

   291     // send to sever

   292     if (priv->m_session->sendSync(QString::number(RemoveDownload), data.toAscii()))

   293         priv->m_session->readAll();

   294     else

   295         setServerError(WRT::ServiceFwIPC::EIPCError);

   296 }

   297 

   298 void DownloadManagerClient::pauseAll()

   299 {

   300     DM_PRIVATE(DownloadManagerClient);

   301     if (!priv->m_isConnected) {

   302         if (!initServer())

   303             return;

   304     }

   305 

   306     // create string to send

   307     QString data;

   308     data.append(encodeString(priv->m_clientName));

   309 

   310     // send to sever

   311     if (priv->m_session->sendSync(QString::number(PauseAll), data.toAscii()))

   312         priv->m_session->readAll();

   313     else

   314         setServerError(WRT::ServiceFwIPC::EIPCError);

   315 }

   316 

   317 void DownloadManagerClient::resumeAll()

   318 {

   319     DM_PRIVATE(DownloadManagerClient);

   320     if (!priv->m_isConnected) {

   321         if (!initServer())

   322             return;

   323     }

   324 

   325     // create string to send

   326     QString data;

   327     data.append(encodeString(priv->m_clientName));

   328 

   329     // send to sever

   330     if (priv->m_session->sendSync(QString::number(ResumeAll), data.toAscii()))

   331         priv->m_session->readAll();

   332     else

   333         setServerError(WRT::ServiceFwIPC::EIPCError);

   334 }

   335 

   336 void DownloadManagerClient::removeAll()

   337 {

   338     DM_PRIVATE(DownloadManagerClient);

   339     if (!priv->m_isConnected) {

   340         if (!initServer())

   341             return;

   342     }

   343 

   344     // create string to send

   345     QString data;

   346     data.append(encodeString(priv->m_clientName));

   347 

   348     // send to sever

   349     if (priv->m_session->sendSync(QString::number(RemoveAll), data.toAscii()))

   350         priv->m_session->readAll();

   351     else

   352         setServerError(WRT::ServiceFwIPC::EIPCError);

   353 }

   354 

   355 QVariant DownloadManagerClient::getDownloadManagerAttribute(DownloadManagerAttribute attr)

   356 {

   357     DM_PRIVATE(DownloadManagerClient);

   358     QVariant returnValue;

   359     if (!priv->m_isConnected) {

   360         if (!initServer())

   361             return returnValue;

   362     }

   363 

   364     // create string to send

   365     QString data;

   366     data.append(encodeString(priv->m_clientName));

   367     data.append(DM_FIELD_DELIMITER);

   368     data.append(QString::number(attr));

   369 

   370     // send to sever

   371     if (priv->m_session->sendSync(QString::number(GetDownloadManagerAttribute), data.toAscii())) {

   372         // expected response is

   373         // list[0] -> attribute

   374         // list[1] -> value

   375         QByteArray bytes = priv->m_session->readAll();

   376         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   377         if (list.count() == 2) {

   378             if (list[0] == QString::number(attr))

   379                 returnValue = QVariant(list[1]);

   380         }

   381     }

   382     else {

   383         setServerError(WRT::ServiceFwIPC::EIPCError);

   384     }

   385     return returnValue;

   386 }

   387 

   388 int DownloadManagerClient::setDownloadManagerAttribute(DownloadManagerAttribute attr, const QVariant& value)

   389 {

   390     DM_PRIVATE(DownloadManagerClient);

   391     int returnValue(-1);

   392     if (!priv->m_isConnected) {

   393         if (!initServer())

   394             return returnValue;

   395     }

   396 

   397     // create string to send

   398     QString data;

   399     data.append(encodeString(priv->m_clientName));

   400     data.append(DM_FIELD_DELIMITER);

   401     data.append(QString::number(attr));

   402     data.append(DM_FIELD_DELIMITER);

   403     data.append(encodeString(value.toString()));

   404 

   405     // send to sever

   406     if (priv->m_session->sendSync(QString::number(SetDownloadManagerAttribute), data.toAscii())) {

   407         // expected response is

   408         // list[0] -> attribute

   409         // list[1] -> returnValue

   410         QByteArray bytes = priv->m_session->readAll();

   411         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   412         if (list.count() == 2) {

   413             if (list[0] == QString::number(attr))

   414                 returnValue = list[1].toInt();

   415         }

   416     }

   417     else {

   418         setServerError(WRT::ServiceFwIPC::EIPCError);

   419     }

   420     return returnValue;

   421 }

   422 

   423 int DownloadManagerClient::startDownload(int dlId)

   424 {

   425     DM_PRIVATE(DownloadManagerClient);

   426     int returnValue(-1);

   427     if (!priv->m_isConnected) {

   428         if (!initServer())

   429             return returnValue;

   430     }

   431 

   432     // create string to send

   433     QString data;

   434     data.append(encodeString(priv->m_clientName));

   435     data.append(DM_FIELD_DELIMITER);

   436     data.append(QString::number(dlId));

   437 

   438     // send to sever

   439     if (priv->m_session->sendSync(QString::number(StartDownload), data.toAscii())) {

   440         // expected response is

   441         // list[0] -> downloadId

   442         // list[1] -> returnValue

   443         QByteArray bytes = priv->m_session->readAll();

   444         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   445         if (list.count() == 2) {

   446             if (list[0] == QString::number(dlId))

   447                 returnValue = list[1].toInt();

   448         }

   449     }

   450     else {

   451         setServerError(WRT::ServiceFwIPC::EIPCError);

   452     }

   453     return returnValue;

   454 }

   455 

   456 int DownloadManagerClient::pauseDownload(int dlId)

   457 {

   458     DM_PRIVATE(DownloadManagerClient);

   459     int returnValue(-1);

   460     if (!priv->m_isConnected) {

   461         if (!initServer())

   462             return returnValue;

   463     }

   464 

   465     // create string to send

   466     QString data;

   467     data.append(encodeString(priv->m_clientName));

   468     data.append(DM_FIELD_DELIMITER);

   469     data.append(QString::number(dlId));

   470 

   471     // send to sever

   472     if (priv->m_session->sendSync(QString::number(PauseDownload), data.toAscii())) {

   473         // expected response is

   474         // list[0] -> downloadId

   475         // list[1] -> returnValue

   476         QByteArray bytes = priv->m_session->readAll();

   477         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   478         if (list.count() == 2) {

   479             if (list[0] == QString::number(dlId))

   480                 returnValue = list[1].toInt();

   481         }

   482     }

   483     else {

   484         setServerError(WRT::ServiceFwIPC::EIPCError);

   485     }

   486     return returnValue;

   487 }

   488 

   489 int DownloadManagerClient::resumeDownload(int dlId)

   490 {

   491     DM_PRIVATE(DownloadManagerClient);

   492     int returnValue(-1);

   493     if (!priv->m_isConnected) {

   494         if (!initServer())

   495             return returnValue;

   496     }

   497 

   498     // create string to send

   499     QString data;

   500     data.append(encodeString(priv->m_clientName));

   501     data.append(DM_FIELD_DELIMITER);

   502     data.append(QString::number(dlId));

   503 

   504     // send to sever

   505     if (priv->m_session->sendSync(QString::number(ResumeDownload), data.toAscii())) {

   506         // expected response is

   507         // list[0] -> downloadId

   508         // list[1] -> returnValue

   509         QByteArray bytes = priv->m_session->readAll();

   510         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   511         if (list.count() == 2) {

   512             if (list[0] == QString::number(dlId))

   513                 returnValue = list[1].toInt();

   514         }

   515     }

   516     else {

   517         setServerError(WRT::ServiceFwIPC::EIPCError);

   518     }

   519     return returnValue;

   520 }

   521 

   522 int DownloadManagerClient::cancelDownload(int dlId)

   523 {

   524     DM_PRIVATE(DownloadManagerClient);

   525     int returnValue(-1);

   526     if (!priv->m_isConnected) {

   527         if (!initServer())

   528             return returnValue;

   529     }

   530 

   531     // create string to send

   532     QString data;

   533     data.append(encodeString(priv->m_clientName));

   534     data.append(DM_FIELD_DELIMITER);

   535     data.append(QString::number(dlId));

   536 

   537     // send to sever

   538     if (priv->m_session->sendSync(QString::number(CancelDownload), data.toAscii())) {

   539         // expected response is

   540         // list[0] -> downloadId

   541         // list[1] -> returnValue

   542         QByteArray bytes = priv->m_session->readAll();

   543         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   544         if (list.count() == 2) {

   545             if (list[0] == QString::number(dlId))

   546                 returnValue = list[1].toInt();

   547         }

   548     }

   549     else {

   550         setServerError(WRT::ServiceFwIPC::EIPCError);

   551     }

   552     return returnValue;

   553 }

   554 

   555 QVariant DownloadManagerClient::getDownloadAttribute(int dlId, DownloadAttribute attr)

   556 {

   557     DM_PRIVATE(DownloadManagerClient);

   558     QVariant returnValue;

   559     if (!priv->m_isConnected) {

   560         if (!initServer())

   561             return returnValue;

   562     }

   563 

   564     // create string to send

   565     QString data;

   566     data.append(encodeString(priv->m_clientName));

   567     data.append(DM_FIELD_DELIMITER);

   568     data.append(QString::number(dlId));

   569     data.append(DM_FIELD_DELIMITER);

   570     data.append(QString::number(attr));

   571 

   572     // send to sever

   573     if (priv->m_session->sendSync(QString::number(GetDownloadAttribute), data.toAscii())) {

   574         // expected response is

   575         // list[0] -> downloadId

   576         // list[1] -> attribute

   577         // list[2] -> value

   578         QByteArray bytes = priv->m_session->readAll();

   579         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   580         if (list.count() == 3) {

   581             if ((list[0] == QString::number(dlId)) &&

   582                 (list[1] == QString::number(attr)))

   583                 returnValue = QVariant(list[2]);

   584         }

   585     }

   586     else {

   587         setServerError(WRT::ServiceFwIPC::EIPCError);

   588     }

   589     return returnValue;

   590 }

   591 

   592 int DownloadManagerClient::setDownloadAttribute(int dlId, DownloadAttribute attr, const QVariant& value)

   593 {

   594     DM_PRIVATE(DownloadManagerClient);

   595     int returnValue(-1);

   596     if (!priv->m_isConnected) {

   597         if (!initServer())

   598             return returnValue;

   599     }

   600 

   601     // create string to send

   602     QString data;

   603     data.append(encodeString(priv->m_clientName));

   604     data.append(DM_FIELD_DELIMITER);

   605     data.append(QString::number(dlId));

   606     data.append(DM_FIELD_DELIMITER);

   607     data.append(QString::number(attr));

   608     data.append(DM_FIELD_DELIMITER);

   609     data.append(encodeString(value.toString()));

   610 

   611     // send to sever

   612     if (priv->m_session->sendSync(QString::number(SetDownloadAttribute), data.toAscii())) {

   613         // expected response is

   614         // list[0] -> downloadId

   615         // list[1] -> attribute

   616         // list[2] -> returnValue

   617         QByteArray bytes = priv->m_session->readAll();

   618         QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

   619         if (list.count() == 3) {

   620             if ((list[0] == QString::number(dlId)) &&

   621                 (list[1] == QString::number(attr)))

   622                 returnValue = list[2].toInt();

   623         }

   624     }

   625     else

   626     {

   627         setServerError(WRT::ServiceFwIPC::EIPCError);

   628     }

   629     return returnValue;

   630 }

   631 

   632 // poll server for events

   633 void DownloadManagerClient::getEvents()

   634 {

   635     DM_PRIVATE(DownloadManagerClient);

   636     if (!priv->m_isConnected) {

   637         if (!initServer())

   638             return;

   639     }

   640 

   641     // create string to send

   642     QString data;

   643     data.append(encodeString(priv->m_clientName));

   644 

   645     // send to sever

   646     if (priv->m_session->sendSync(QString::number(GetEvents), data.toAscii())) {

   647         // expected response has a list of downloadmanager and download events

   648         QString eventMsg = priv->m_session->readAll();

   649         if (!eventMsg.isEmpty())

   650             processEvents(eventMsg);

   651 

   652         // start timer for getting next set of events

   653         priv->m_timer->start(EVENTS_REQUEST_INTERVAL);

   654     }

   655     else {

   656         setServerError(WRT::ServiceFwIPC::EIPCError);

   657     }

   658 }

   659 

   660 // process Download and DownloadManager events

   661 void DownloadManagerClient::processEvents(QString eventMsg)

   662 {

   663     DM_PRIVATE(DownloadManagerClient);

   664 

   665     // Separate out the fields of an event

   666     QStringList list = eventMsg.split(DM_FIELD_DELIMITER);

   667     if (list.count() >= 2) {

   668         QString eventName = list[0];

   669         // // check type of event

   670         if (list[0] == QString::number(EventDownloadManager)) {

   671             // Download Manager event

   672             DEventType type = (DEventType)list[1].toInt();

   673             // post event

   674             priv->m_downloadManager->postEvent(type, NULL);

   675         }

   676         else if (list[0] == QString::number(EventDownload)) {

   677             // Download event

   678             int dlId = list[1].toInt();

   679             DEventType type = (DEventType)list[2].toInt();

   680             BackgroundDownload* dl = dynamic_cast<BackgroundDownload*>(priv->m_downloadManager->findDownload(dlId));

   681             // post event

   682             if (dl)

   683                 dl->postEvent(type, NULL);

   684         }

   685     }

   686 }

   687 

   688 // encode string so that it does not contain any communication delimiter

   689 QString DownloadManagerClient::encodeString(const QString& inputString)

   690 {

   691     QByteArray bytes = QUrl::toPercentEncoding(inputString);

   692     return bytes.data();

   693 }

   694 

   695 // get server connection/communication error

   696 int DownloadManagerClient::serverError()

   697 {

   698     DM_PRIVATE(DownloadManagerClient);

   699     return priv->m_error;

   700 }

   701 

   702 // set server IPC error

   703 void DownloadManagerClient::setServerError(int error)

   704 {

   705     DM_PRIVATE(DownloadManagerClient);

   706     priv->m_error = error;

   707     // client could have died

   708     // mark client as disconnected so that it can reconnect again

   709     priv->m_isConnected = false;

   710     if (priv->m_timer->isActive())

   711         priv->m_timer->stop();

   712     priv->m_downloadManager->postEvent(DisconnectedFromServer, NULL);

   713     priv->m_downloadManager->postEvent(ServerError, NULL);

   714 }