Nova Flow OS
KDE Developer Platform
KDE Developer Platform
  • KDE Developer Platform
    • Getting started
      • Building KDE software
        • KDE software
        • Where to find the development team
        • Learning more
        • Choose what to work on
        • Source code cross-referencing
        • Installing build dependencies
        • Set up a development environment
        • Building KDE software with kdesrc-build
        • Basic troubleshooting
        • Tips and tricks
        • IDE Configuration
          • Setting up an IDE for KDE development
          • Visual Studio Code
          • Qt Creator
          • Kate
          • KDevelop
          • CLion
          • Sublime Text
        • Building KDE software manually
        • Building KDE software with distrobox and podman
      • Kirigami
        • KDE is ours
        • Setting up and getting started
        • Explaining pages
        • Layouts, ListViews, and Cards
        • Adding actions
        • Adding a dialog
        • Using separate files
        • Next steps
        • Colors and themes in Kirigami
        • Typography
        • Actions based components
        • Page rows and page stacks
        • Scrollable pages and list views
        • Cards
        • Drawers
        • Chips
        • Dialog types
        • Controls and interactive elements
        • Form layouts
        • Inline messages
        • Action toolbars
        • Progress bars and indicators
        • List views
        • Understanding CMakeLists
        • Figuring out main.cpp
        • Connect logic to your QML user interface
        • Connect models to your QML user interface
        • About page
        • Introduction to Kirigami Addons
        • FormCard About pages
        • Form delegates in your settings pages
      • KXmlGui
        • Getting started with KXmlGui
        • Hello World!
        • Creating the main window
        • Using actions
        • Saving and loading
        • Command line interface
      • Python with Kirigami
        • Apps with QML and Python
        • Your first Python + Kirigami application
        • Creating a Python package
        • Creating a Flatpak
      • Common programming mistakes
      • Adding a new KDE project
    • Features
      • Icons
      • Configuration
        • The KConfig Framework
        • Introduction to KConfig
        • Using KConfig XT
        • KDE Frameworks 6 porting guide
        • Settings module (KCM) development
        • KConfigDialog
      • D-Bus
        • What is D-Bus practically useful for?
        • Introduction to D-Bus
        • Accessing D-Bus interfaces
        • Intermediate D-Bus
        • Creating D-Bus interfaces
        • Using custom types with D-Bus
        • D-Bus autostart services
      • Create your own mouse cursor theme
      • Session management
      • Archives
      • Desktop file
      • KAuth
        • Privilege Escalation
        • Using actions in your applications
      • KIdleTime
      • Akonadi: personal information management
        • Debugging Akonadi Resources
        • Using Akonadi in applications
      • Concurrent programming
      • Solid
      • Sonnet
    • Plasma themes and plugins
      • Getting started
      • Plasma Widget tutorial
        • How to create a plasmoid
        • Setup
        • Porting Plasmoids to KF6
        • Testing
        • QML
        • Plasma's QML API
        • Widget Properties
        • Configuration
        • Translations / i18n
        • Examples
        • C++ API
      • KWin Effects
      • Plasma Desktop scripting
        • Javascript Interaction With Plasma Shells
        • Templates
        • Examples
        • API documentation
        • Configuration keys
      • Plasma Style tutorial
        • Creating a Plasma Style quickstart
        • Understanding Plasma Styles
        • SVG elements and Inkscape
        • Background SVG format
        • System and accent colors
        • Theme elements reference
        • Porting themes to Plasma 5
        • Porting themes to Plasma 6
      • Aurorae window decorations
      • KWin scripting tutorial
        • Quick start
        • KWin scripting API
      • Wallpapers
      • Plasma comic
        • Tutorial
        • Testing and debugging
        • Examples
      • Create a custom Window Switcher
      • KRunner C++ Plugin
        • Basic Anatomy of a Runner
        • KRunner metadata format
    • Applications
      • Creating sensor faces
      • Dolphin
        • Creating Dolphin service menus
      • Kate
        • Kate plugin tutorial
      • KMines
        • Making a KMines theme
      • Writing tests
        • Appium automation testing
    • Packaging
      • Android
        • KDE on Android
        • Building applications for Android
        • Packaging and publishing applications for Android
        • Publishing on Google Play
          • Introduction
          • Packaging your app
          • Adding your app to Google Play
          • Publishing your app
          • Releasing new versions of old apps
        • Porting applications to Android
          • Basic porting
          • Making applications run well on Android
          • Metadata
      • Windows
        • Packaging and publishing applications for Windows
        • Publish your app in the Microsoft Store
          • Packaging your app for the Microsoft Store
          • Submitting your app to the Microsoft Store
      • Plasma Mobile
        • KDE on mobile devices
        • Porting a new device to Plasma Mobile
        • KDE Telephony stack
          • General Overview
          • Kernel layer
          • System daemons
            • General overview
            • Developing Telephony functionality
            • ModemManager Telephony functions
          • Session daemons
          • QML declarative plugin layer
          • KDE application layer
        • Execute applications
      • Distributing KDE software as Flatpak
        • Your first Flatpak
        • Extending your package
        • Nightly Flatpaks and Flathub
        • Testing your Flatpak
    • System administration
      • Shell scripting with KDE dialogs
      • Kiosk: Simple configuration management for large deployment
        • Abstract
        • Introduction to Kiosk
        • Kiosk keys
    • Contribute to the documentation
    • About
      • Readme
      • License
        • Creative Commons Attribution-ShareAlike 4.0 International
        • GNU General Public License 3.0 or later
Powered by GitBook
On this page
  1. KDE Developer Platform
  2. Packaging
  3. Plasma Mobile
  4. KDE Telephony stack

Session daemons

Userland D-Bus IPC, KDE Telephony stack

PreviousModemManager Telephony functionsNextQML declarative plugin layer

Last updated 8 months ago

ModemManager (or oFono previously) unified access to different modem devices with different command lists via system D-Bus IPC.

The tasks of the session side daemons are (but not limited to):

  • Handle calls and messages

  • Provide calls and messages history

  • Provide contacts PIM mapping

  • Power management

  • Notifications

  • Interacting with other parts of the user environment

  • Filter spam

Worth mentioning dependencies

eg25-manager

is a daemon to handle low-power modes of the Quectel EG25 via ModemManager. It's used for the Pinephone.

kop316 projects

Both projects are developed for Phosh but are . They could be used directly via session-level D-Bus API to implement a Qt/QML library.

If not, at least the D-Bus scheme could be shared among both GNOME and KDE via Freedesktop project. And re-implemented in Qt after that if needed (for example, at modem-daemon repository described below). The described approach will provide interoperability on the GUI application level.

ModemManagerQt

KDE Telephony Meta

  • D-Bus XML Interface descriptions

  • ready to reuse Qt meta types for complex D-Bus types as a header or a static library

Daemons

Modem Daemon

  • Provide access to calls for client applications and daemons via D-Bus session level

  • Save the history

The daemon is written in Qt. It is similar to kop316 projects. It's working with the system D-Bus and provides session D-Bus API for applications. It's ModemManagerQt-first, but provides higher-level API so any possible manager switching should be transparent for the application level.

Work-in-Progress.

KDE Telephony Daemon

  • Enable audio channels when needed

  • Show notifications

  • Automatically launch dialer GUI

  • Share KDE-related Telephony services via session DBus

It is KDE-specific and depends on Modem Daemon. It's not ModemManagerQt specific. Could also depend on such KF5 libraries as People, Notifications, I18n. Contains contactphonenumbermapper — a library to work with KDE KPeople and Google phonenumber libraries.

Work-in-Progress.

Relations with Telepathy IM

So, the current dialer client implementation is going to be based on the ModemManager without higher-level TelepathyIM usage, while it still could be interesting to have an IM client solution with interoperability in the long-distant future.

Conclusion

Session daemons on the user-land level could be used to interact with other parts of the user environment and provide a unified API for GUI applications.

is a Qt wrapper for ModemManager DBus API.

is KDE Telephony shared data:

is a daemon for background tracking the modem events to:

It's not KDE specific (just Qt) and could be used directly in projects like or even .

is a daemon for background tracking the modem events to:

is a FreeDesktop project supported by Nokia and Collabora. It's a framework to build instant messaging client applications with interoperability via D-Bus IPC. It could use oFono or ModemManager to implement calls and messaging clients. oFono integration is .

Telepathy IM could cover both telephony daemons in theory. The project is currently having the contributors' flaws. Telepathy project roots are from the - days of the Nokia N900/N9 Linux devices and team development. A lot of contributors are needed to support such a level of standardization. Right now we have maintainer who has “picked up the flag” and a few other project sympathizers. It’s the well-known chicken-or-the-egg problem that could be solved step-by-step though. The main weak point of the spec is probably .

To provide actual developer libraries (environment- and language-specific) is out of the scope for any session-side telephony daemon. The D-Bus API exported via session bus enabling to handle it.

provides
eg25-manager
SMS/MMS Daemon
Visual Voicemail Daemon
environment-agnostic
ModemManagerQt
kde-telephony-meta
modem-daemon
Nemo Mobile
GNOME Phosh
kde-telephony-daemon
Telepathy IM
already implemented
good
old
Collabora
Kaffeine
service-side history
QML declarative plugin as library side