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
  5. System daemons

General overview

Userland D-Bus IPC, KDE Telephony stack

PreviousSystem daemonsNextDeveloping Telephony functionality

Last updated 8 months ago

General overview: oFono and ModemManager

Even if the modem device is accessible via the OS , the device-specific messages should be handled on the user-land side. To unify the access across different devices and track the modem events, the daemon could be implemented on the user-land level. There're two similar open-source projects currently: oFono and ModemManager. Both are using D-Bus to provide IPC API.

Since its inception, Plasma Mobile has used the oFono stack for telephony functions (mobile data, calling, SMS).

With , we are transitioning our telephony stack to ModemManager.

Both oFono and ModemManager are popular frameworks for the Telephony stack.

ModemManager

is a FreeDesktop project (started in 2008 with the goal of providing USB dongle support for desktops). It integrates with the higher-level NetworkManager network management daemon.

It is currently used on Plasma Desktop and GNOME to provide support for USB modems, as well as on Phosh for telephony functions.

oFono

is a Nokia/Intel project (started in 2009 with the Nokia N900). It integrates with the higher-level ConnMan connection manager.

It is currently used by projects like Ubuntu Touch and Sailfish, which maintain their own series of patches on top of the stack in order for it to work for their use-cases.

Rationale

oFono and ModemManager share similar goals in providing unified API for accessing modem devices via DBus. However, the pace of development has been slow upstream for oFono, with our usage depending on a series of patches in order to have it working.

ModemManager has generally been better in that regard, with active development and new devices being upstreamed. There's also the project for the PinePhone's Quectel EG25 mobile broadband modem, which depends on ModemManager and provides support for low-power modes.

The main drawback of switching off oFono, is that it is the only option for Halium devices. However, due to our recent decision to drop Halium support, this factor is no longer a constraint. (See also: )

On mainlined devices such as the Pinephone and OnePlus 6, ModemManager has also proved to be much more reliable with handling the modem, with much more active development than oFono on that front.

Our goal is to provide the best possible experience on mainline Linux devices, and so using the ModemManager stack will allow us to deliver that for telephony functions.

This also allows us to use the same stack as on Plasma Desktop, allowing for better integration into Plasma and for applications like Dialer and SpaceBar to be used on it.

Status

We have completed our initial switch to ModemManager.

However, the code has not been extensively tested, and so features and fixes will still be rolling out on each Plasma Mobile Gear release (monthly).

Meta-task for ModemManager switch: https://invent.kde.org/teams/plasma-mobile/issues/-/issues/62

Conclusion

System daemon on the user-land level could be used to track modem events and provide unified access to different modem devices with different command lists.

Handling calls or messages history, managing contacts, and interacting with other parts of the user environment are out of the scope of any system-side telephony daemon. The D-Bus API is exported via system bus enabling to handle it.

kernel level
Plasma Mobile Gear 21.10 release
ModemManager
oFono
eg25-manager
kernel layer paragraph of the documentation
the session side