| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the documentation of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:FDL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Free Documentation License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Free |
| ** Documentation License version 1.3 as published by the Free Software |
| ** Foundation and appearing in the file included in the packaging of |
| ** this file. Please review the following information to ensure |
| ** the GNU Free Documentation License version 1.3 requirements |
| ** will be met: https://www.gnu.org/licenses/fdl-1.3.html. |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /*! |
| \page topics-network-connectivity.html |
| \title Networking and Connectivity |
| \brief Qt's network and connectivity features |
| |
| Qt provides classes for both high-level and low-level network communication, |
| classes for web integration, and classes for interprocess communication. |
| |
| For high-level network traffic, \l{Qt Network} provides an abstraction layer |
| over the operations used, showing only high-level classes and functions. Qt |
| Network can also handle lower level protocols like TCP and UDP. Classes like |
| QTcpSocket and QUdpSocket enable the developer to send and receive messages |
| using the TCP or UDP protocol.Name resolution is done with QHostInfo. QHostInfo |
| is called before creating a network connection with QTcpSocket or QUdpSocket. |
| Filtering and redistributing network traffic via proxies can handled by the |
| QNetWorkProxy class. |
| |
| Qt Network also provides the \l{Bearer Management} API. It has functions that |
| can start or stop network interfaces and roam between access points. It does |
| however not take care of the network configurations itself. The platform needs |
| to take care of that. |
| |
| \l{Qt WebEngine} offers a Chromium-based web engine that enables using |
| web content in your application. \l{Qt WebEngine} can render HTML5, XHTML, |
| and SVG documents, and execute Javascript. |
| |
| Qt also offers functionalities for \e{inter-process communication} (IPC). The |
| class QProcess is used to start external programs. \l{Qt D-Bus} provides support |
| for D-Bus, an interprocess communication and remoteprocedure calling mechanism. |
| It mostly communicates via a central server application, called a bus. However, |
| it is also possible to let applications communicate directly with each other. |
| QSharedMemory provides access to a shared memory segment by multiple threads |
| and processes. It is however also possible for a single process to |
| exclusively lock that shared memory. |
| |
| \section1 Network Communication |
| |
| Qt supports a wide range of network communication, with a focus on HTTP, TCP, |
| and UDP. |
| |
| At the HTTP level, the \l{Qt Network} module offers the network access API, |
| which consists mainly of QNetworkRequest, QNetworkAccessManager, and |
| QNetworkReply. Put simply, the QNetworkRequest resembles an HTTP request, which |
| gets passed to the QNetworkAccessManager to send the request on the wire; this |
| class returns a QNetworkReply, which enables parsing the HTTP reply. The network |
| access API uses the socket classes mentioned below (for TCP and SSL) internally. |
| |
| For communication at the socket level, QTcpSocket, QUdpSocket and QSslSocket |
| should be used. These classes offer a synchronous API through the waitFor* |
| methods as well as an asynchronous API; if possible (i.e. if the event loop is |
| running), the asynchronous API should always be preferred. Qt also offers |
| QTcpServer to enable the server-side part of a TCP communication. Please note |
| that there is no HTTP server class in Qt. |
| |
| For secure communication via SSL, Qt Network offers a wide range of classes |
| alongside the central QSslSocket, e.g. QSslCertificate, QSslConfiguration and |
| QSslError. The only supported backend for SSL in Qt is OpenSSL, which needs to |
| be installed separately. |
| |
| For mobile devices, Qt Network offers the \l{Bearer Management}{bearer |
| management} API to track the status of a connection (e.g. getting notified about |
| online/offline status or whether Wifi or 3G is used). |
| |
| Qt also offers HTTP support in QML by either using HTTP explicitly via |
| XmlHttpRequest, or by transparently using HTTP URLs in e.g. Image sources. |
| |
| Related Topics: |
| \list |
| \li \l{Qt Network} - module documentation |
| \list |
| \li \l {Network Programming API} |
| \li \l {Network Programming with Qt} |
| \li \l {Qt Network C++ Classes} |
| \li \l {Secure Sockets Layer (SSL) Classes} |
| \li \l {Bearer Management} |
| \endlist |
| \li \l {Resource Loading and Network Transparency} - network and URL transparency in QML |
| \endlist |
| |
| \section1 WebSockets |
| |
| An alternative to direct TCP or HTTP communication is to use the WebSocket |
| protocol (\l{http://tools.ietf.org/html/rfc6455}{RFC 6455}). It is a |
| two-way communication protocol on top of the TCP protocol to utilize existing |
| web infrastructure without having to create additional client-server based |
| communication. The \l{Qt WebSockets} module provides both a QML and C++ API, |
| in addition to several examples to demonstrate its use. |
| |
| \section1 World Wide Web Support |
| |
| Qt makes it easy to embed web content into your Qt application using features of |
| the Qt WebEngine layout engine. The Qt WebEngine module equips Qt with support |
| for a broad range of standard web technologies that make it possible to embed |
| HTML content styled with CSS and scripted with JavaScript into your Qt |
| application. \l{Qt WebEngine} facilitates both integration with traditional |
| QWidget based desktop applications as well as embedding into Qt Quick QML |
| applications. |
| |
| For more information see \l {Integrating Web Content}. |
| |
| \section1 Inter-Process Communication |
| |
| Qt provides several ways to implement Inter-Process Communication |
| (IPC) in Qt applications. |
| |
| The cross-platform \l{Qt Network} module provides classes that make |
| network programming portable and easy. It offers high-level |
| classes (e.g., QNetworkAccessManager, QFtp) that communicate using |
| specific application-level protocols, and lower-level classes |
| (e.g., QTcpSocket, QTcpServer, QSslSocket) for implementing |
| protocols. |
| |
| The cross-platform shared memory class, QSharedMemory, provides |
| access to the operating system's shared memory implementation. |
| It allows safe access to shared memory segments by multiple threads |
| and processes. Additionally, QSystemSemaphore can be used to control |
| access to resources shared by the system, as well as to communicate |
| between processes. |
| |
| The \l{Qt D-Bus} module is a cross-platform library you can use to |
| implement IPC using the D-Bus protocol. It extends Qt's |
| \l{Signals & Slots}{signals and slots} mechanism to the IPC |
| level, allowing a signal emitted by one process to be connected to |
| a slot in another process. |
| |
| The cross-platform class \l{QProcess} can be used to start external |
| programs as child processes, and to communicate with them. It provides |
| an API for monitoring and controlling the state of the child |
| process. QProcess gives access to the input/output channels of child |
| process by inheriting from QIODevice. |
| |
| The \l{QLocalSocket} class provides a local socket. On Windows this is |
| a named pipe and on Unix this is a local domain socket. |
| The \l{QLocalServer} class provides a local socket based server. This |
| class makes it possible to accept incoming local socket connections. |
| |
| Related Topics: |
| |
| \list |
| \li \l {Qt D-Bus} - module documentation |
| \list |
| \li \l {Using Qt D-Bus Adaptors} |
| \li \l {Declaring Signals in D-Bus Adaptors} |
| \li \l {Declaring Slots in D-Bus Adaptors} |
| \li \l {The Qt D-Bus Type System} |
| \li \l {Qt D-Bus XML compiler (qdbusxml2cpp)} |
| \endlist |
| \li \l {QLocalSocket} |
| \li \l {QSharedMemory} |
| \endlist |
| |
| \section1 Serial Port Communication |
| |
| The \l{Qt Serial Port} module provides a C++ API for communicating |
| through serial ports, using the RS-232 standard. It works with physical |
| ports and also with drivers that emulate these ports. Examples of serial |
| port emulators include virtual COM ports, com0com emulators, and the |
| Bluetooth SPP. |
| |
| This module is designed to make serial port programming easier and portable. |
| As of Qt 5.2, it is supported on \l{Qt for Windows}{Windows}, \l{Qt for macOS}{\macos}, |
| and \l{Qt for Linux/X11}{Linux}. |
| |
| Related topics: |
| \list |
| \li \l {Qt Serial Port} - module documentation |
| \li \l {Qt Serial Port C++ Classes} |
| \endlist |
| |
| \section1 Bluetooth Communication |
| |
| The \l{Qt Bluetooth} module provides both C++ and QML APIs for the |
| short-range (less than 100 meters) wireless protocol developed by the |
| \l{Bluetooth SIG}{Bluetooth Special Interest Group}. It provides |
| classic Bluetooth and Bluetooth Low Energy features. |
| |
| Related topics: |
| \list |
| \li \l {Qt Bluetooth} - module documentation |
| \list |
| \li \l {Qt Bluetooth Overview} {Bluetooth Classic} |
| \li \l {Bluetooth Low Energy Overview} {Bluetooth Low Energy} |
| \li \l {Qt Bluetooth C++ Classes} |
| \li \l {Qt Bluetooth QML Types} |
| \endlist |
| \endlist |
| |
| |
| \section1 Near Field Communication |
| |
| The \l{Qt NFC} module provides both C++ and QML APIs for the extremely |
| short-range (less than 20 centimeters) wireless protocol developed by the |
| \l{http://www.nfc-forum.org}{NFC Forum}. |
| |
| Related topics: |
| \list |
| \li \l {Qt NFC} - module documentation |
| \list |
| \li \l {Qt NFC Overview} |
| \li \l {Qt NFC C++ Classes} |
| \li \l {Qt NFC QML Types} |
| \endlist |
| \endlist |
| |
| */ |