Qt Interface Framework Inter-Process Communication Integration

An Inter-Process Communication (IPC) enables APIs to be split into multiple processes. Each process runs independently, sometimes on a separate host machine, and the communication is done using an IPC. The IPC also allows for multiple clients, or frontends to access the same service. These frontends can be, for example, the main Infotainment System UI, or different applications that run within the UI or mobile devices.

Benefits of using an IPC

An IPC enables functionality distribution and information sharing, between multiple processes or even between multiple host machines. Separate processes improve the overall reliability of a complex system and make it possible to separate computation-intensive code from the UI code. Additionally, backends that use an IPC can be accessible via multiple frontend points, be it the central UI, separate applications, or even mobile devices or third party applications.

Combined with QtInterfaceFramework's automatic code generation and uniform feature loading, developing distributed features requires less development overhead, with more interchangeability and transparency for the UI code.

The Qt Interface Framework Generator makes it possible to generate Middleware Backends using different IPC mechanisms. The generated backend plugins are loaded and used in the same way as any other QtInterfaceFramework plugin and are interchangeable with any other backend implementation with the same API. Since all method calls over QtInterfaceFramework feature interfaces are asynchronous, switching between IPC mechanisms is transparent to the frontend code.

The Qt Interface Framework Generator currently supports the following IPC mechanisms:

Qt Remote Objects

The Qt Interface Framework Generator can generate Middleware Backends that use the Qt Remote Objects module as communication channel. The generated code is split between a client and a server part. The client-side code is generated as a QtInterfaceFramework backend plugin and as a Middleware Service, either a server stub or a full simulation server. The client is generated using the backend_qtro template; the server using the server_qtro template or server_qtro_simulator. Both the plugin and the server contain generated C++ code and an intermediate .rep file that is further processed by Qt's replica compiler to produce the actual source and replica classes.

The generated plugin is buildable and usable as-is; you don't have to make any changes. Your task is then to implement the intended functionality on the server-side. To help you get started with the server, there's a generated class included, which initializes the connection. All connection parameters to the plugin and to the server are passed over a config file, either in a default location or at a user-specified path.

For a steb-by-step introduction to remote backends, see the Qt Interface Framework Generator Remote Example.

MQTT

The Qt Interface Framework Generator can generate Middleware Backends that use the QtMqtt module to communicate via the MQTT protocol. The client-side code is generated as a QtInterfaceFramework backend plugin using the backend_mqtt template.

The generated plugin subscribes to MQTT topics to receive property values and signal events, and publishes to topics to set property values and invoke operations. Each property, signal, and operation is mapped to a configurable MQTT topic, controlled via @config_mqtt annotations in the QFace IDL file or its accompanying YAML file.

The generated plugin is loaded and used in the same way as other QtInterfaceFramework plugins and is interchangeable with any other backend implementation with the same API.

Unlike the QtRemoteObjects-based templates, the backend_mqtt template does not generate a corresponding server. The MQTT broker and the server-side implementation must be provided separately.