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 |
|
42 #include <QEventLoop> |
|
43 #include <QTimer> |
|
44 |
|
45 #include "qnetworksession.h" |
|
46 |
|
47 #ifdef Q_OS_SYMBIAN |
|
48 #include "qnetworksession_s60_p.h" |
|
49 #elif defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5) |
|
50 #include "qnetworksession_maemo_p.h" |
|
51 #else |
|
52 #include "qnetworksession_p.h" |
|
53 #endif |
|
54 |
|
55 QTM_BEGIN_NAMESPACE |
|
56 |
|
57 /*! |
|
58 \class QNetworkSession |
|
59 |
|
60 \brief The QNetworkSession class provides control over the system's access points |
|
61 and enables session management for cases when multiple clients access the same access point. |
|
62 |
|
63 \inmodule QtNetwork |
|
64 \ingroup bearer |
|
65 |
|
66 A QNetworkSession enables control over the system's network interfaces. The session's configuration |
|
67 parameter are determined via the QNetworkConfiguration object to which it is bound. Depending on the |
|
68 type of the session (single access point or service network) a session may be linked to one or more |
|
69 network interfaces. By means of \l{open()}{opening} and \l{close()}{closing} of network sessions |
|
70 a developer can start and stop the systems network interfaces. If the configuration represents |
|
71 multiple access points (see \l QNetworkConfiguration::ServiceNetwork) more advanced features such as roaming may be supported. |
|
72 |
|
73 QNetworkSession supports session management within the same process and depending on the platform's |
|
74 capabilities may support out-of-process sessions. If the same |
|
75 network configuration is used by multiple open sessions the underlying network interface is only terminated once |
|
76 the last session has been closed. |
|
77 |
|
78 \section1 Roaming |
|
79 |
|
80 Applications may connect to the preferredConfigurationChanged() signal in order to |
|
81 receive notifications when a more suitable access point becomes available. |
|
82 In response to this signal the application must either initiate the roaming via migrate() |
|
83 or ignore() the new access point. Once the session has roamed the |
|
84 newConfigurationActivated() signal is emitted. The application may now test the |
|
85 carrier and must either accept() or reject() it. The session will return to the previous |
|
86 access point if the roaming was rejected. The subsequent state diagram depicts the required |
|
87 state transitions. |
|
88 |
|
89 \image roaming-states.png |
|
90 |
|
91 Some platforms may distinguish forced roaming and application level roaming (ALR). |
|
92 ALR implies that the application controls (via migrate(), ignore(), accept() and reject()) |
|
93 whether a network session can roam from one access point to the next. Such control is useful |
|
94 if the application maintains stateful socket connections and wants to control the transition from |
|
95 one interface to the next. Forced roaming implies that the system automatically roams to the next network without |
|
96 consulting the application. This has the advantage that the application can make use of roaming features |
|
97 without actually being aware of it. It is expected that the application detects that the underlying |
|
98 socket is broken and automatically reconnects via the new network link. |
|
99 |
|
100 If the platform supports both modes of roaming, an application indicates its preference |
|
101 by connecting to the preferredConfigurationChanged() signal. Connecting to this signal means that |
|
102 the application wants to take control over the roaming behavior and therefore implies application |
|
103 level roaming. If the client does not connect to the preferredConfigurationChanged(), forced roaming |
|
104 is used. If forced roaming is not supported the network session will not roam by default. |
|
105 |
|
106 Some applications may want to suppress any form of roaming altogether. Possible use cases may be |
|
107 high priority downloads or remote services which cannot handle a roaming enabled client. Clients |
|
108 can suppress roaming by connecting to the preferredConfigurationChanged() signal and answer each |
|
109 signal emission with ignore(). |
|
110 |
|
111 \sa QNetworkConfiguration, QNetworkConfigurationManager |
|
112 */ |
|
113 |
|
114 /*! |
|
115 \enum QNetworkSession::State |
|
116 |
|
117 This enum describes the connectivity state of the session. If the session is based on a |
|
118 single access point configuration the state of the session is the same as the state of the |
|
119 associated network interface. |
|
120 |
|
121 \value Invalid The session is invalid due to an invalid configuration. This may |
|
122 happen due to a removed access point or a configuration that was |
|
123 invalid to begin with. |
|
124 \value NotAvailable The session is based on a defined but not yet discovered QNetworkConfiguration |
|
125 (see \l QNetworkConfiguration::StateFlag). |
|
126 \value Connecting The network session is being established. |
|
127 \value Connected The network session is connected. If the current process wishes to use this session |
|
128 it has to register its interest by calling open(). A network session |
|
129 is considered to be ready for socket operations if it isOpen() and connected. |
|
130 \value Closing The network session is in the process of being shut down. |
|
131 \value Disconnected The network session is not connected. The associated QNetworkConfiguration |
|
132 has the state QNetworkConfiguration::Discovered. |
|
133 \value Roaming The network session is roaming from one access point to another |
|
134 access point. |
|
135 */ |
|
136 |
|
137 /*! |
|
138 \enum QNetworkSession::SessionError |
|
139 |
|
140 This enum describes the session errors that can occur. |
|
141 |
|
142 \value UnknownSessionError An unidentified error occurred. |
|
143 \value SessionAbortedError The session was aborted by the user or system. |
|
144 \value RoamingError The session cannot roam to a new configuration. |
|
145 \value OperationNotSupportedError The operation is not supported for current configuration. |
|
146 \value InvalidConfigurationError The operation cannot currently be performed for the |
|
147 current configuration. |
|
148 */ |
|
149 |
|
150 /*! |
|
151 \fn void QNetworkSession::stateChanged(QNetworkSession::State state) |
|
152 |
|
153 This signal is emitted whenever the state of the network session changes. |
|
154 The \a state parameter is the new state. |
|
155 |
|
156 \sa state() |
|
157 */ |
|
158 |
|
159 /*! |
|
160 \fn void QNetworkSession::error(QNetworkSession::SessionError error) |
|
161 |
|
162 This signal is emitted after an error occurred. The \a error parameter |
|
163 describes the error that occurred. |
|
164 |
|
165 \sa error(), errorString() |
|
166 */ |
|
167 |
|
168 /*! |
|
169 \fn void QNetworkSession::preferredConfigurationChanged(const QNetworkConfiguration& config, bool isSeamless) |
|
170 |
|
171 This signal is emitted when the preferred configuration/access point for the |
|
172 session changes. Only sessions which are based on service network configurations |
|
173 may emit this signal. \a config can be used to determine access point specific |
|
174 details such as proxy settings and \a isSeamless indicates whether roaming will |
|
175 break the sessions IP address. |
|
176 |
|
177 As a consequence to this signal the application must either start the roaming process |
|
178 by calling migrate() or choose to ignore() the new access point. |
|
179 |
|
180 If the roaming process is non-seamless the IP address will change which means that |
|
181 a socket becomes invalid. However seamless mobility can ensure that the local IP address |
|
182 does not change. This is achieved by using a virtual IP address which is bound to the actual |
|
183 link address. During the roaming process the virtual address is attached to the new link |
|
184 address. |
|
185 |
|
186 Some platforms may support the concept of Forced Roaming and Application Level Roaming (ALR). |
|
187 Forced roaming implies that the platform may simply roam to a new configuration without |
|
188 consulting applications. It is up to the application to detect the link layer loss and reestablish |
|
189 its sockets. In contrast ALR provides the opportunity to prevent the system from roaming. |
|
190 If this session is based on a configuration that supports roaming the application can choose |
|
191 whether it wants to be consulted (ALR use case) by connecting to this signal. For as long as this signal |
|
192 connection remains the session remains registered as a roaming stakeholder; otherwise roaming will |
|
193 be enforced by the platform. |
|
194 |
|
195 \sa migrate(), ignore(), QNetworkConfiguration::isRoamingAvailable() |
|
196 */ |
|
197 |
|
198 /*! |
|
199 \fn void QNetworkSession::newConfigurationActivated() |
|
200 |
|
201 This signal is emitted once the session has roamed to the new access point. |
|
202 The application may reopen its socket and test the suitability of the new network link. |
|
203 Subsequently it must either accept() or reject() the new access point. |
|
204 |
|
205 \sa accept(), reject() |
|
206 */ |
|
207 |
|
208 /*! |
|
209 \fn void QNetworkSession::opened() |
|
210 |
|
211 This signal is emitted when the network session has been opened. |
|
212 |
|
213 The underlying network interface will not be shut down as long as the session remains open. |
|
214 Note that this feature is dependent on \l{QNetworkConfigurationManager::SystemSessionSupport}{system wide session support}. |
|
215 */ |
|
216 |
|
217 /*! |
|
218 \fn void QNetworkSession::closed() |
|
219 |
|
220 This signal is emitted when the network session has been closed. |
|
221 */ |
|
222 |
|
223 /*! |
|
224 Constructs a session based on \a connectionConfig with the given \a parent. |
|
225 |
|
226 \sa QNetworkConfiguration |
|
227 */ |
|
228 QNetworkSession::QNetworkSession(const QNetworkConfiguration& connectionConfig, QObject* parent) |
|
229 : QObject(parent) |
|
230 { |
|
231 d = new QNetworkSessionPrivate; |
|
232 d->q = this; |
|
233 d->publicConfig = connectionConfig; |
|
234 d->syncStateWithInterface(); |
|
235 QObject::connect(d, SIGNAL(quitPendingWaitsForOpened()), |
|
236 this, SIGNAL(opened())); |
|
237 } |
|
238 |
|
239 /*! |
|
240 Frees the resources associated with the QNetworkSession object. |
|
241 */ |
|
242 QNetworkSession::~QNetworkSession() |
|
243 { |
|
244 delete d; |
|
245 } |
|
246 |
|
247 /*! |
|
248 Creates an open session which increases the session counter on the underlying network interface. |
|
249 The system will not terminate a network interface until the session reference counter reaches zero. |
|
250 Therefore an open session allows an application to register its use of the interface. |
|
251 |
|
252 As a result of calling open() the interface will be started if it is not connected/up yet. |
|
253 Some platforms may not provide support for out-of-process sessions. On such platforms the session |
|
254 counter ignores any sessions held by another process. The platform capabilities can be |
|
255 detected via QNetworkConfigurationManager::capabilities(). |
|
256 |
|
257 Note that this call is asynchronous. Depending on the outcome of this call the results can be enquired |
|
258 by connecting to the stateChanged(), opened() or error() signals. |
|
259 |
|
260 It is not a requirement to open a session in order to monitor the underlying network interface. |
|
261 |
|
262 \sa close(), stop(), isOpen() |
|
263 */ |
|
264 void QNetworkSession::open() |
|
265 { |
|
266 d->open(); |
|
267 } |
|
268 |
|
269 /*! |
|
270 Waits until the session has been opened, up to \a msecs milliseconds. If the session has been opened, this |
|
271 function returns true; otherwise it returns false. In the case where it returns false, you can call error() |
|
272 to determine the cause of the error. |
|
273 |
|
274 The following example waits up to one second for the session to be opened: |
|
275 |
|
276 \code |
|
277 session->open(); |
|
278 if (session->waitForOpened(1000)) |
|
279 qDebug("Open!"); |
|
280 \endcode |
|
281 |
|
282 If \a msecs is -1, this function will not time out. |
|
283 |
|
284 \sa open(), error() |
|
285 */ |
|
286 bool QNetworkSession::waitForOpened(int msecs) |
|
287 { |
|
288 if (d->isOpen) |
|
289 return true; |
|
290 |
|
291 if (d->state != Connecting) |
|
292 return false; |
|
293 |
|
294 QEventLoop* loop = new QEventLoop(this); |
|
295 QObject::connect(d, SIGNAL(quitPendingWaitsForOpened()), |
|
296 loop, SLOT(quit())); |
|
297 QObject::connect(this, SIGNAL(error(QNetworkSession::SessionError)), |
|
298 loop, SLOT(quit())); |
|
299 |
|
300 //final call |
|
301 if (msecs>=0) |
|
302 QTimer::singleShot(msecs, loop, SLOT(quit())); |
|
303 |
|
304 loop->exec(); |
|
305 loop->disconnect(); |
|
306 loop->deleteLater(); |
|
307 |
|
308 return d->isOpen; |
|
309 } |
|
310 |
|
311 /*! |
|
312 Decreases the session counter on the associated network configuration. If the session counter reaches zero |
|
313 the active network interface is shut down. This also means that state() will only change from \l Connected to |
|
314 \l Disconnected if the current session was the last open session. |
|
315 |
|
316 If the platform does not support out-of-process sessions calling this function does not stop the |
|
317 interface. In this case \l{stop()} has to be used to force a shut down. |
|
318 The platform capabilities can be detected via QNetworkConfigurationManager::capabilities(). |
|
319 |
|
320 Note that this call is asynchronous. Depending on the outcome of this call the results can be enquired |
|
321 by connecting to the stateChanged(), opened() or error() signals. |
|
322 |
|
323 \sa open(), stop(), isOpen() |
|
324 */ |
|
325 void QNetworkSession::close() |
|
326 { |
|
327 d->close(); |
|
328 } |
|
329 |
|
330 /*! |
|
331 Invalidates all open sessions against the network interface and therefore stops the |
|
332 underlying network interface. This function always changes the session's state() flag to |
|
333 \l Disconnected. |
|
334 |
|
335 On Symbian platform, a 'NetworkControl' capability is required for |
|
336 full interface-level stop (without the capability, only the current session is stopped). |
|
337 |
|
338 \sa open(), close() |
|
339 */ |
|
340 void QNetworkSession::stop() |
|
341 { |
|
342 d->stop(); |
|
343 } |
|
344 |
|
345 /*! |
|
346 Returns the QNetworkConfiguration that this network session object is based on. |
|
347 |
|
348 \sa QNetworkConfiguration |
|
349 */ |
|
350 QNetworkConfiguration QNetworkSession::configuration() const |
|
351 { |
|
352 return d->publicConfig; |
|
353 } |
|
354 |
|
355 /* |
|
356 Returns the type of bearer currently used by this session. The string is not translated and |
|
357 therefore can not be shown to the user. The subsequent table presents the currently known |
|
358 bearer types: |
|
359 |
|
360 \table |
|
361 \header |
|
362 \o Value |
|
363 \o Description |
|
364 \row |
|
365 \o Unknown |
|
366 \o The session is based on an unknown or unspecified bearer type. |
|
367 \row |
|
368 \o Ethernet |
|
369 \o The session is based on Ethernet. |
|
370 \row |
|
371 \o WLAN |
|
372 \o The session is based on Wireless LAN. |
|
373 \row |
|
374 \o 2G |
|
375 \o The session uses CSD, GPRS, HSCSD, EDGE or cdmaOne. |
|
376 \row |
|
377 \o CDMA2000 |
|
378 \o The session uses CDMA. |
|
379 \row |
|
380 \o WCDMA |
|
381 \o The session uses W-CDMA/UMTS. |
|
382 \row |
|
383 \o HSPA |
|
384 \o The session uses High Speed Packet Access. |
|
385 \row |
|
386 \o Bluetooth |
|
387 \o The session uses Bluetooth. |
|
388 \row |
|
389 \o WiMAX |
|
390 \o The session uses WiMAX. |
|
391 \endtable |
|
392 |
|
393 If the session is based on a network configuration of type |
|
394 \l QNetworkConfiguration::ServiceNetwork the type of the preferred or currently |
|
395 active configuration is returned. Therefore the bearer type may change |
|
396 over time. |
|
397 |
|
398 This function returns an empty string if this session is based on an invalid configuration, or |
|
399 a network configuration of type \l QNetworkConfiguration::ServiceNetwork with no |
|
400 \l {QNetworkConfiguration::children()}{children}. |
|
401 */ |
|
402 /*QString QNetworkSession::bearerName() const |
|
403 { |
|
404 return d->bearerName(); |
|
405 }*/ |
|
406 |
|
407 /*! |
|
408 Returns the network interface that is used by this session. |
|
409 |
|
410 This function only returns a valid QNetworkInterface when this session is \l Connected. |
|
411 |
|
412 The returned interface may change as a result of a roaming process. |
|
413 |
|
414 Note: this function does not work in Symbian emulator due to the way the |
|
415 connectivity is emulated on Windows. |
|
416 |
|
417 \sa state() |
|
418 */ |
|
419 QNetworkInterface QNetworkSession::interface() const |
|
420 { |
|
421 return d->currentInterface(); |
|
422 } |
|
423 |
|
424 /*! |
|
425 Returns true if this session is open. If the number of all open sessions is greater than |
|
426 zero the underlying network interface will remain connected/up. |
|
427 |
|
428 The session can be controlled via open() and close(). |
|
429 */ |
|
430 bool QNetworkSession::isOpen() const |
|
431 { |
|
432 return d->isOpen; |
|
433 } |
|
434 |
|
435 /*! |
|
436 Returns the state of the session. |
|
437 |
|
438 If the session is based on a single access point configuration the state of the |
|
439 session is the same as the state of the associated network interface. Therefore |
|
440 a network session object can be used to monitor network interfaces. |
|
441 |
|
442 A \l QNetworkConfiguration::ServiceNetwork based session summarizes the state of all its children |
|
443 and therefore returns the \l Connected state if at least one of the service network's |
|
444 \l {QNetworkConfiguration::children()}{children()} configurations is active. |
|
445 |
|
446 Note that it is not required to hold an open session in order to obtain the network interface state. |
|
447 A connected but closed session may be used to monitor network interfaces whereas an open and connected |
|
448 session object may prevent the network interface from being shut down. |
|
449 |
|
450 \sa error(), stateChanged() |
|
451 */ |
|
452 QNetworkSession::State QNetworkSession::state() const |
|
453 { |
|
454 return d->state; |
|
455 } |
|
456 |
|
457 /*! |
|
458 Returns the type of error that last occurred. |
|
459 |
|
460 \sa state(), errorString() |
|
461 */ |
|
462 QNetworkSession::SessionError QNetworkSession::error() const |
|
463 { |
|
464 return d->error(); |
|
465 } |
|
466 |
|
467 /*! |
|
468 Returns a human-readable description of the last device error that |
|
469 occurred. |
|
470 |
|
471 \sa error() |
|
472 */ |
|
473 QString QNetworkSession::errorString() const |
|
474 { |
|
475 return d->errorString(); |
|
476 } |
|
477 |
|
478 /*! |
|
479 Returns the value for property \a key. |
|
480 |
|
481 A network session can have properties attached which may describe the session in more details. |
|
482 This function can be used to gain access to those properties. |
|
483 |
|
484 The following property keys are guaranteed to be specified on all platforms: |
|
485 |
|
486 \table |
|
487 \header |
|
488 \o Key \o Description |
|
489 \row |
|
490 \o ActiveConfiguration |
|
491 \o If the session \l isOpen() this property returns the identifier of the |
|
492 QNetworkConfiguration that is used by this session; otherwise an empty string. |
|
493 |
|
494 The main purpose of this key is to determine which Internet access point is used |
|
495 if the session is based on a \l{QNetworkConfiguration::ServiceNetwork}{ServiceNetwork}. |
|
496 The following code snippet highlights the difference: |
|
497 \code |
|
498 QNetworkConfigurationManager mgr; |
|
499 QNetworkConfiguration ap = mgr.defaultConfiguration(); |
|
500 QNetworkSession* session = new QNetworkSession(ap); |
|
501 ... //code activates session |
|
502 |
|
503 QString ident = session->sessionProperty("ActiveConfiguration").toString(); |
|
504 if ( ap.type() == QNetworkConfiguration::ServiceNetwork ) { |
|
505 Q_ASSERT( ap.identifier() != ident ); |
|
506 Q_ASSERT( ap.children().contains( mgr.configurationFromIdentifier(ident) ) ); |
|
507 } else if ( ap.type() == QNetworkConfiguration::InternetAccessPoint ) { |
|
508 Q_ASSERT( ap.identifier() == ident ); |
|
509 } |
|
510 \endcode |
|
511 \row |
|
512 \o UserChoiceConfiguration |
|
513 \o If the session \l isOpen() and is bound to a QNetworkConfiguration of type |
|
514 UserChoice, this property returns the identifier of the QNetworkConfiguration that the |
|
515 configuration resolved to when \l open() was called; otherwise an empty string. |
|
516 |
|
517 The purpose of this key is to determine the real QNetworkConfiguration that the |
|
518 session is using. This key is different to \i ActiveConfiguration in that |
|
519 this key may return an identifier for either a |
|
520 \l {QNetworkConfiguration::ServiceNetwork}{service network} or a |
|
521 \l {QNetworkConfiguration::InternetAccessPoint}{Internet access points} configurations |
|
522 whereas \i ActiveConfiguration always returns identifiers to |
|
523 \l {QNetworkConfiguration::InternetAccessPoint}{Internet access points} configurations. |
|
524 \row |
|
525 \o ConnectInBackground |
|
526 \o Setting this property to \i true before calling \l open() implies that the connection attempt |
|
527 is made but if no connection can be established, the user is not connsulted and asked to select |
|
528 a suitable connection. This property is not set by default and support for it depends on the platform. |
|
529 \endtable |
|
530 */ |
|
531 QVariant QNetworkSession::sessionProperty(const QString& key) const |
|
532 { |
|
533 if (!d->publicConfig.isValid()) |
|
534 return QVariant(); |
|
535 |
|
536 if (key == "ActiveConfiguration") { |
|
537 if (!d->isOpen) |
|
538 return QString(); |
|
539 else |
|
540 return d->activeConfig.identifier(); |
|
541 } |
|
542 |
|
543 if (key == "UserChoiceConfiguration") { |
|
544 if (!d->isOpen || d->publicConfig.type() != QNetworkConfiguration::UserChoice) |
|
545 return QString(); |
|
546 |
|
547 if (d->serviceConfig.isValid()) |
|
548 return d->serviceConfig.identifier(); |
|
549 else |
|
550 return d->activeConfig.identifier(); |
|
551 } |
|
552 |
|
553 return d->sessionProperty(key); |
|
554 } |
|
555 |
|
556 /*! |
|
557 Sets the property \a value on the session. The property is identified using |
|
558 \a key. Removing an already set property can be achieved by passing an |
|
559 invalid QVariant. |
|
560 |
|
561 Note that the \i UserChoiceConfiguration and \i ActiveConfiguration |
|
562 properties are read only and cannot be changed using this method. |
|
563 */ |
|
564 void QNetworkSession::setSessionProperty(const QString& key, const QVariant& value) |
|
565 { |
|
566 if (key == "ActiveConfiguration" |
|
567 || key == "UserChoiceConfiguration") |
|
568 return; |
|
569 |
|
570 d->setSessionProperty(key, value); |
|
571 } |
|
572 |
|
573 /*! |
|
574 Instructs the session to roam to the new access point. The old access point remains active |
|
575 until the application calls accept(). |
|
576 |
|
577 The newConfigurationActivated() signal is emitted once roaming has been completed. |
|
578 |
|
579 \sa accept() |
|
580 */ |
|
581 void QNetworkSession::migrate() |
|
582 { |
|
583 d->migrate(); |
|
584 } |
|
585 |
|
586 /*! |
|
587 This function indicates that the application does not wish to roam the session. |
|
588 |
|
589 \sa migrate() |
|
590 */ |
|
591 void QNetworkSession::ignore() |
|
592 { |
|
593 // Needed on at least Symbian platform: the roaming must be explicitly |
|
594 // ignore()'d or migrate()'d |
|
595 d->ignore(); |
|
596 } |
|
597 |
|
598 /*! |
|
599 Instructs the session to permanently accept the new access point. Once this function |
|
600 has been called the session may not return to the old access point. |
|
601 |
|
602 The old access point may be closed in the process if there are no other network sessions for it. |
|
603 Therefore any open socket that still uses the old access point |
|
604 may become unusable and should be closed before completing the migration. |
|
605 */ |
|
606 void QNetworkSession::accept() |
|
607 { |
|
608 d->accept(); |
|
609 } |
|
610 |
|
611 /*! |
|
612 The new access point is not suitable for the application. By calling this function the |
|
613 session returns to the previous access point/configuration. This action may invalidate |
|
614 any socket that has been created via the not desired access point. |
|
615 |
|
616 \sa accept() |
|
617 */ |
|
618 void QNetworkSession::reject() |
|
619 { |
|
620 d->reject(); |
|
621 } |
|
622 |
|
623 |
|
624 /*! |
|
625 Returns the amount of data sent in bytes; otherwise 0. |
|
626 |
|
627 This field value includes the usage across all open network |
|
628 sessions which use the same network interface. |
|
629 |
|
630 If the session is based on a service network configuration the number of |
|
631 sent bytes across all active member configurations are returned. |
|
632 |
|
633 This function may not always be supported on all platforms and returns 0. |
|
634 The platform capability can be detected via QNetworkConfigurationManager::DataStatistics. |
|
635 |
|
636 \note On some platforms this function may run the main event loop. |
|
637 */ |
|
638 quint64 QNetworkSession::bytesWritten() const |
|
639 { |
|
640 return d->bytesWritten(); |
|
641 } |
|
642 |
|
643 /*! |
|
644 Returns the amount of data received in bytes; otherwise 0. |
|
645 |
|
646 This field value includes the usage across all open network |
|
647 sessions which use the same network interface. |
|
648 |
|
649 If the session is based on a service network configuration the number of |
|
650 sent bytes across all active member configurations are returned. |
|
651 |
|
652 This function may not always be supported on all platforms and returns 0. |
|
653 The platform capability can be detected via QNetworkConfigurationManager::DataStatistics. |
|
654 |
|
655 \note On some platforms this function may run the main event loop. |
|
656 */ |
|
657 quint64 QNetworkSession::bytesReceived() const |
|
658 { |
|
659 return d->bytesReceived(); |
|
660 } |
|
661 |
|
662 /*! |
|
663 Returns the number of seconds that the session has been active. |
|
664 */ |
|
665 quint64 QNetworkSession::activeTime() const |
|
666 { |
|
667 return d->activeTime(); |
|
668 } |
|
669 |
|
670 /*! |
|
671 \internal |
|
672 |
|
673 This function is required to detect whether the client wants to control |
|
674 the roaming process. If he connects to preferredConfigurationChanged() signal |
|
675 he intends to influence it. Otherwise QNetworkSession always roams |
|
676 without registering this session as a stakeholder in the roaming process. |
|
677 |
|
678 For more details check the Forced vs ALR roaming section in the QNetworkSession |
|
679 class description. |
|
680 */ |
|
681 void QNetworkSession::connectNotify(const char *signal) |
|
682 { |
|
683 QObject::connectNotify(signal); |
|
684 //check for preferredConfigurationChanged() signal connect notification |
|
685 //This is not required on all platforms |
|
686 #ifdef Q_OS_SYMBIAN |
|
687 if (qstrcmp(signal, SIGNAL(preferredConfigurationChanged(QNetworkConfiguration,bool))) == 0) { |
|
688 d->setALREnabled(true); |
|
689 } |
|
690 #endif |
|
691 } |
|
692 |
|
693 /*! |
|
694 \internal |
|
695 |
|
696 This function is called when the client disconnects from the preferredConfigurationChanged() |
|
697 signal. |
|
698 |
|
699 \sa connectNotify() |
|
700 */ |
|
701 void QNetworkSession::disconnectNotify(const char *signal) |
|
702 { |
|
703 QObject::disconnectNotify(signal); |
|
704 //check for preferredConfigurationChanged() signal disconnect notification |
|
705 //This is not required on all platforms |
|
706 #ifdef Q_OS_SYMBIAN |
|
707 if (qstrcmp(signal, SIGNAL(preferredConfigurationChanged(QNetworkConfiguration,bool))) == 0) { |
|
708 d->setALREnabled(false); |
|
709 } |
|
710 #endif |
|
711 } |
|
712 |
|
713 #include "moc_qnetworksession.cpp" |
|
714 |
|
715 QTM_END_NAMESPACE |
|