ConnMan on AGL ivi-homescreen, Part 3: D-Bus Operations with sdbus-c++

In Part 2 we walked through the plugin’s registration and how MethodChannel calls are dispatched and EventChannel subscriptions are managed. In this part we go deeper into the two D-Bus operation modules: ConnmanTechnology (Wi-Fi radio control) and ConnmanService (network operations), and explore the patterns used when working with sdbus-c++.

sdbus-c++ Primer

sdbus-c++ is a high-level C++ wrapper over libsystemd’s D-Bus API. It provides:

Proxy objects (sdbus::createProxy) to call remote D-Bus methods.
Object objects (sdbus::createObject) to implement D-Bus interfaces (used in Part 4 for the Agent).
Signal subscriptions via proxy->uponSignal(...).onInterface(...).call(lambda).
Async method calls via callMethodAsync(...).getResultAsFuture<>().get().

The key type in sdbus-c++ is sdbus::Variant — a type-erased container matching D-Bus’s variant type. Checking what type it holds and extracting the value looks like this:

1
sdbus::Variant v = /* ... */;
2
if (v.containsValueOfType<std::string>()) {
3
  std::string s = v.get<std::string>();
4
} else if (v.containsValueOfType<bool>()) {
5
  bool b = v.get<bool>();
6
}

ConnMan uses map<string, Variant> for property dictionaries — a pattern that repeats throughout the codebase.

The Helper Functions

Before looking at the modules, the shared utilities in connman_helpers.h are worth examining because they appear everywhere:

1
// Extract a string property from a ConnMan D-Bus property map.
2
inline std::string GetStringProp(
3
    const std::map<std::string, sdbus::Variant>& props,
4
    const std::string& key) {
5
  auto it = props.find(key);
6
  if (it != props.end() && it->second.containsValueOfType<std::string>()) {
7
    return it->second.get<std::string>();
8
  }
9
  return "";
10
}
11

12
inline bool GetBoolProp(const std::map<std::string, sdbus::Variant>& props,
13
                        const std::string& key) { /* ... */ }
14

15
inline uint8_t GetByteProp(const std::map<std::string, sdbus::Variant>& props,
16
                            const std::string& key) { /* ... */ }
17

18
// For Security — ConnMan returns a list; we take the first entry.
19
inline std::string GetStringArrayFirst(
20
    const std::map<std::string, sdbus::Variant>& props,
21
    const std::string& key) {
22
  auto it = props.find(key);
23
  if (it != props.end() &&
24
      it->second.containsValueOfType<std::vector<std::string>>()) {
25
    auto vec = it->second.get<std::vector<std::string>>();
26
    if (!vec.empty()) return vec.front();
27
  }
28
  return "";
29
}

These helpers normalize the variant extraction and return safe defaults — essential for robustness on embedded systems where properties may be absent.

ConnmanTechnology: Wi-Fi Radio Control

Discovering the Wi-Fi Technology Path

ConnMan represents each network technology (Wi-Fi, Bluetooth, Ethernet) as a D-Bus object at a path like /net/connman/technology/wifi. Rather than hardcoding this path, the plugin discovers it dynamically by calling net.connman.Manager.GetTechnologies:

1
std::string ConnmanTechnology::GetWifiTechnologyPath() {
2
  try {
3
    auto& bus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
4
    auto proxy = sdbus::createProxy(bus, sdbus::ServiceName("net.connman"),
5
                                    sdbus::ObjectPath("/"));
6
    std::vector<sdbus::Struct<sdbus::ObjectPath,
7
                              std::map<std::string, sdbus::Variant>>> techs;
8
    proxy->callMethod("GetTechnologies")
9
        .onInterface("net.connman.Manager")
10
        .storeResultsTo(techs);
11

12
    for (const auto& tech : techs) {
13
      if (GetStringProp(tech.get<1>(), "Type") == "wifi") {
14
        return tech.get<0>().c_str();  // e.g. "/net/connman/technology/wifi"
15
      }
16
    }
17
  } catch (const sdbus::Error& e) { /* ... */ }
18
  return "";
19
}

GetTechnologies returns a vector of (ObjectPath, Properties) structs. We iterate and look for Type == "wifi". This is more robust than using a hardcoded path because the technology path might differ on some hardware.

GetWifiTechnology

This method translates a ConnMan technology entry into a Dart Map:

1
void ConnmanTechnology::GetWifiTechnology(
2
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
3
  try {
4
    // ... get techs via GetTechnologies ...
5
    for (const auto& tech : techs) {
6
      const auto& props = tech.get<1>();
7
      if (GetStringProp(props, "Type") == "wifi") {
8
        flutter::EncodableMap m;
9
        m[flutter::EncodableValue("powered")] =
10
            flutter::EncodableValue(GetBoolProp(props, "Powered"));
11
        m[flutter::EncodableValue("connected")] =
12
            flutter::EncodableValue(GetBoolProp(props, "Connected"));
13
        m[flutter::EncodableValue("type")] =
14
            flutter::EncodableValue(std::string("wifi"));
15
        m[flutter::EncodableValue("name")] =
16
            flutter::EncodableValue(GetStringProp(props, "Name"));
17
        m[flutter::EncodableValue("path")] =
18
            flutter::EncodableValue(tech.get<0>().c_str());
19
        result->Success(flutter::EncodableValue(m));
20
        return;
21
      }
22
    }
23
    result->Success(flutter::EncodableValue());  // no wifi
24
  } catch (const sdbus::Error& e) {
25
    result->Error("DBUS_ERROR", e.getMessage());
26
  }
27
}

This runs synchronously on the platform thread — GetTechnologies is a fast, local query that doesn’t block meaningfully.

SetWifiPowered and ScanWifi — Background Threading

Powering the Wi-Fi radio on/off and triggering a scan can take time — ConnMan may wait for the driver to respond. Blocking the Flutter platform thread would freeze the UI. The solution is to offload to a background thread:

1
void ConnmanTechnology::SetWifiPowered(
2
    bool powered,
3
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
4
  std::string tech_path = GetWifiTechnologyPath();
5
  if (tech_path.empty()) {
6
    result->Error("NOT_FOUND", "WiFi technology not available");
7
    return;
8
  }
9

10
  // Move result into a shared_ptr so the lambda can extend its lifetime.
11
  auto shared = std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>>(
12
      std::move(result));
13

14
  std::thread([shared, powered, tech_path]() {
15
    try {
16
      auto& bus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
17
      auto proxy = sdbus::createProxy(bus, sdbus::ServiceName("net.connman"),
18
                                      sdbus::ObjectPath(tech_path));
19
      proxy->callMethodAsync("SetProperty")
20
          .onInterface("net.connman.Technology")
21
          .withArguments("Powered", sdbus::Variant(powered))
22
          .getResultAsFuture<>()
23
          .get();
24
      shared->Success(flutter::EncodableValue(true));
25
    } catch (const sdbus::Error& e) {
26
      shared->Error("DBUS_ERROR", e.getMessage());
27
    }
28
  }).detach();
29
}

The pattern is consistent for all blocking operations:

Wrap result in shared_ptr — unique_ptr can’t be captured by value in a lambda. A shared_ptr extends its lifetime to match the thread’s.
Spawn a detached thread — simple and sufficient for one-shot operations.
Call async, then .get() — callMethodAsync().getResultAsFuture<>().get() issues the D-Bus call and blocks the background thread (not the platform thread) until ConnMan replies.
Call Success or Error on shared — Flutter’s MethodResult is thread-safe for this usage.

Note

ScanWifi uses the identical pattern, calling net.connman.Technology.Scan instead of SetProperty. A Wi-Fi scan can take several seconds — the thread pattern is essential here.

Subscribing to Technology PropertyChanged

When the Wi-Fi radio is powered on or off — whether by our plugin or by external means — ConnMan emits a PropertyChanged signal. We subscribe to this in SubscribeToPropertyChanged:

1
void ConnmanTechnology::SubscribeToPropertyChanged(
2
    std::vector<std::unique_ptr<sdbus::IProxy>>& proxies,
3
    std::mutex& sink_mutex,
4
    std::unique_ptr<flutter::EventSink<flutter::EncodableValue>>& event_sink) {
5
  auto& bus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
6
  // Fetch all technologies to get their paths
7
  auto mgr = sdbus::createProxy(bus, "net.connman", "/");
8
  // ... get techList ...
9

10
  for (const auto& tech : techList) {
11
    auto tech_proxy = sdbus::createProxy(bus, "net.connman", tech.get<0>());
12
    tech_proxy->uponSignal("PropertyChanged")
13
        .onInterface("net.connman.Technology")
14
        .call([&sink_mutex, &event_sink,
15
               path = std::string(tech.get<0>().c_str())](
16
                  const std::string& name, const sdbus::Variant& value) {
17
          flutter::EncodableMap event;
18
          event[flutter::EncodableValue("type")] =
19
              flutter::EncodableValue(std::string("technologyPropertyChanged"));
20
          event[flutter::EncodableValue("path")] =
21
              flutter::EncodableValue(path);
22
          event[flutter::EncodableValue("name")] =
23
              flutter::EncodableValue(name);
24
          // Marshal the variant value to a Dart-compatible type
25
          if (value.containsValueOfType<std::string>()) {
26
            event[flutter::EncodableValue("value")] =
27
                flutter::EncodableValue(value.get<std::string>());
28
          } else if (value.containsValueOfType<bool>()) {
29
            event[flutter::EncodableValue("value")] =
30
                flutter::EncodableValue(value.get<bool>());
31
          }
32
          std::lock_guard<std::mutex> lock(sink_mutex);
33
          if (event_sink) {
34
            event_sink->Success(flutter::EncodableValue(event));
35
          }
36
        });
37
    proxies.push_back(std::move(tech_proxy));
38
  }
39
}

The path is captured by value in the lambda (via path = std::string(...)) because the original D-Bus object’s lifetime is not guaranteed after the loop iteration ends.

ConnmanService: Network Operations

GetWifiServices

GetWifiServices fetches all services from net.connman.Manager.GetServices and filters to Wi-Fi only:

1
void ConnmanService::GetWifiServices(
2
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
3
  try {
4
    auto& bus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
5
    auto proxy = sdbus::createProxy(bus, "net.connman", "/");
6
    std::vector<sdbus::Struct<sdbus::ObjectPath,
7
                              std::map<std::string, sdbus::Variant>>> services;
8
    proxy->callMethod("GetServices")
9
        .onInterface("net.connman.Manager")
10
        .storeResultsTo(services);
11

12
    flutter::EncodableList list;
13
    for (const auto& srv : services) {
14
      const auto& props = srv.get<1>();
15
      if (GetStringProp(props, "Type") == "wifi") {
16
        flutter::EncodableMap m;
17
        m[flutter::EncodableValue("path")]     = srv.get<0>().c_str();
18
        m[flutter::EncodableValue("name")]     = GetStringProp(props, "Name");
19
        m[flutter::EncodableValue("state")]    = GetStringProp(props, "State");
20
        m[flutter::EncodableValue("strength")] = GetByteProp(props, "Strength");
21
        m[flutter::EncodableValue("security")] = GetStringArrayFirst(props, "Security");
22
        list.push_back(flutter::EncodableValue(m));
23
      }
24
    }
25
    result->Success(flutter::EncodableValue(list));
26
  } catch (const sdbus::Error& e) {
27
    result->Error("DBUS_ERROR", e.getMessage());
28
  }
29
}

ConnMan returns services in priority order — connected/favorite services appear first. The Security field is a vector<string> (e.g. ["psk"]), so GetStringArrayFirst returns just the first entry.

Connect, Disconnect, Remove — Async Pattern

All three service mutation operations follow the same background-thread pattern:

1
void ConnmanService::ConnectService(
2
    const std::string& path,
3
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
4
  auto shared = std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>>(
5
      std::move(result));
6
  std::thread([shared, path]() {
7
    try {
8
      auto& bus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
9
      auto proxy = sdbus::createProxy(bus, "net.connman", sdbus::ObjectPath(path));
10
      proxy->callMethodAsync("Connect")
11
          .onInterface("net.connman.Service")
12
          .getResultAsFuture<>()
13
          .get();
14
      shared->Success(flutter::EncodableValue(true));
15
    } catch (const sdbus::Error& e) {
16
      shared->Error("DBUS_ERROR", e.getMessage());
17
    }
18
  }).detach();
19
}

net.connman.Service.Connect can block for many seconds — it performs the full association and DHCP negotiation. Without the background thread this would freeze the Flutter UI.

Tip

When connecting to a WPA2 network, ConnMan will call back into our registered Agent (see Part 4) to request the passphrase. This happens on the D-Bus event loop thread, also blocking the Connect call until the passphrase is supplied.

ServicesChanged — Pushing Fresh Snapshots

ConnMan’s ServicesChanged signal on net.connman.Manager fires when the service list changes — networks appear/disappear, or their order changes. Rather than forwarding the diff, the plugin re-fetches the full list and pushes it:

1
void ConnmanService::PushServicesUpdate(
2
    std::mutex& sink_mutex,
3
    std::unique_ptr<flutter::EventSink<flutter::EncodableValue>>& event_sink) {
4
  try {
5
    // ... fetch services same as GetWifiServices ...
6
    flutter::EncodableMap event;
7
    event[flutter::EncodableValue("type")] =
8
        flutter::EncodableValue(std::string("servicesChanged"));
9
    event[flutter::EncodableValue("services")] =
10
        flutter::EncodableValue(list);
11

12
    std::lock_guard<std::mutex> lock(sink_mutex);
13
    if (event_sink) {
14
      event_sink->Success(flutter::EncodableValue(event));
15
    }
16
  } catch (...) { /* ... */ }
17
}

Re-fetching the full snapshot is simpler than applying diffs and avoids state synchronization bugs.

Service PropertyChanged

Each known service also gets a PropertyChanged subscription, giving the Dart layer per-property updates:

1
srv_proxy->uponSignal("PropertyChanged")
2
    .onInterface("net.connman.Service")
3
    .call([&sink_mutex, &event_sink, path = ...](
4
              const std::string& name, const sdbus::Variant& value) {
5
      flutter::EncodableMap event;
6
      event["type"] = "servicePropertyChanged";
7
      event["path"] = path;
8
      event["name"] = name;
9
      // Map variant types: string, bool, uint8 (Strength) → int
10
      if (value.containsValueOfType<uint8_t>()) {
11
        event["value"] = static_cast<int32_t>(value.get<uint8_t>());
12
      } else if (...) { /* string, bool */ }
13
      std::lock_guard<std::mutex> lock(sink_mutex);
14
      if (event_sink) event_sink->Success(flutter::EncodableValue(event));
15
    });

Note the uint8_t case for Strength — ConnMan reports signal strength as a byte (0–100%), but Flutter’s EncodableValue doesn’t have a uint8_t type, so it is widened to int32_t.

Summary

In this part we covered:

The sdbus-c++ patterns for calling D-Bus methods (callMethod, callMethodAsync), subscribing to signals (uponSignal), and extracting variants.
ConnmanTechnology: discovering the Wi-Fi path dynamically, reading technology properties, running SetProperty(Powered) and Scan on background threads.
ConnmanService: listing services (with Type == "wifi" filter), running Connect/Disconnect/Remove on background threads, pushing servicesChanged events as full snapshots, and subscribing to per-service PropertyChanged signals.
The background thread pattern (shared_ptr<MethodResult> + std::thread) for keeping the Flutter platform thread unblocked.

In Part 4, we tackle the most interesting challenge: the ConnMan Agent — a D-Bus object we implement ourselves, which ConnMan calls back into when it needs credentials, and which bridges that call across to a Flutter dialog via std::promise/future.