ConnMan on AGL ivi-homescreen, Part 4: The Agent, promise/future Bridge & Flutter UI

In Part 3 we covered the Wi-Fi technology and service operations using sdbus-c++. In this final part we tackle the most architecturally interesting component: the ConnMan Agent.

When ConnMan needs to connect to a WPA2 network, it cannot simply proceed — it needs the user’s passphrase. ConnMan gets it by calling a D-Bus agent that the client application registers. Our agent must bridge that D-Bus call (on the D-Bus event loop thread) across to a Flutter UI dialog (on the Flutter platform thread) and then return the result synchronously back to ConnMan. This part explains exactly how we do that using std::promise/future.

The ConnMan Agent Protocol

ConnMan’s net.connman.Agent interface specifies four methods:

Method	When Called
`RequestInput(service, fields)`	ConnMan needs credentials (passphrase, etc.)
`ReportError(service, error)`	ConnMan reports a connection failure
`RequestBrowser(service, url)`	Captive portal — open a browser (Wi-Fi hotspot login)
`Release()`	ConnMan is releasing the agent
`Cancel()`	In-progress `RequestInput` cancelled

Of these, RequestInput is the one that matters most for Wi-Fi. It is a synchronous D-Bus method — ConnMan blocks, waiting for the return value, which should be a map<string, Variant> containing the credentials.

Registering the Agent Object

In connman_agent.cc, the constructor creates a D-Bus object at path /net/connman/flutter_agent and registers all the methods of the net.connman.Agent interface:

1
ConnmanAgent::ConnmanAgent(
2
    flutter::MethodChannel<flutter::EncodableValue>* channel)
3
    : channel_(channel) {
4
  auto& sysBus = plugin_common_sdbus::SystemDBus::Instance().GetConnection();
5
  agent_object_ = sdbus::createObject(sysBus, sdbus::ObjectPath(kAgentPath));
6

7
  agent_object_
8
      ->addVTable(
9
          sdbus::registerMethod("Release").implementedAs(
10
              [this]() { Release(); }),
11
          sdbus::registerMethod("ReportError")
12
              .withInputParamNames("service", "error")
13
              .implementedAs([this](const sdbus::ObjectPath& svc,
14
                                   const std::string& err) {
15
                ReportError(svc, err);
16
              }),
17
          sdbus::registerMethod("RequestBrowser")
18
              .withInputParamNames("service", "url")
19
              .implementedAs([this](const sdbus::ObjectPath& svc,
20
                                   const std::string& url) {
21
                RequestBrowser(svc, url);
22
              }),
23
          sdbus::registerMethod("RequestInput")
24
              .withInputParamNames("service", "fields")
25
              .withOutputParamNames("inputs")
26
              .implementedAs(
27
                  [this](const sdbus::ObjectPath& svc,
28
                         const std::map<std::string, sdbus::Variant>& flds) {
29
                    return RequestInput(svc, flds);
30
                  }),
31
          sdbus::registerMethod("Cancel").implementedAs(
32
              [this]() { Cancel(); }))
33
      .forInterface("net.connman.Agent");
34

35
  // Tell ConnMan about our agent
36
  auto mgr = sdbus::createProxy(sysBus, "net.connman", "/");
37
  mgr->callMethod("RegisterAgent")
38
      .onInterface("net.connman.Manager")
39
      .withArguments(sdbus::ObjectPath(kAgentPath));
40
}

When the plugin is destroyed, the destructor calls UnregisterAgent to cleanly remove the agent from ConnMan.

The Threading Challenge

RequestInput is where things get complex. Here is the situation:

1
D-Bus event loop thread:
2
  ConnMan → calls net.connman.Agent.RequestInput
3
  Our C++ handler must RETURN the passphrase synchronously
4

5
Flutter platform thread:
6
  Flutter dialog must be shown and awaited for the user to type the passphrase

We cannot show a Flutter dialog from the D-Bus thread — MethodChannel::InvokeMethod must be called from the Flutter platform thread. But we cannot block the Flutter platform thread to wait for the result, because that would deadlock (the platform thread processes the dialog callbacks).

The solution is std::promise/future:

Create a promise<map<string, Variant>> on the D-Bus thread.
Get the corresponding future from the promise, also on the D-Bus thread.
Call InvokeMethod("requestInput", ...) on the Flutter platform thread (MethodChannel dispatches onto it internally).
Set up success/error callbacks that resolve the promise.
Block the D-Bus thread on future.get() — waiting for the promise to be resolved.
The Flutter dialog runs, the user types the passphrase, the callback fires, the promise is resolved, future.get() unblocks, and we return the credentials to ConnMan.

RequestInput Implementation

1
std::map<std::string, sdbus::Variant> ConnmanAgent::RequestInput(
2
    const sdbus::ObjectPath& service,
3
    const std::map<std::string, sdbus::Variant>& fields) {
4

5
  // Step 1: Create the promise/future pair on the D-Bus thread.
6
  auto promise = std::make_shared<
7
      std::promise<std::map<std::string, sdbus::Variant>>>();
8
  auto future = promise->get_future();
9

10
  // Step 2: Build the argument map to send to Dart.
11
  //         Tell Dart which fields ConnMan needs (e.g. "Passphrase").
12
  flutter::EncodableMap dart_fields;
13
  for (const auto& pair : fields) {
14
    dart_fields[flutter::EncodableValue(pair.first)] =
15
        flutter::EncodableValue(pair.first);
16
  }
17
  flutter::EncodableMap args;
18
  args[flutter::EncodableValue("service")] =
19
      flutter::EncodableValue(service.c_str());
20
  args[flutter::EncodableValue("fields")] =
21
      flutter::EncodableValue(dart_fields);
22

23
  // Step 3: Invoke "requestInput" on the Flutter MethodChannel.
24
  //         This schedules execution on the Flutter platform thread.
25
  channel_->InvokeMethod(
26
      "requestInput",
27
      std::make_unique<flutter::EncodableValue>(std::move(args)),
28
      std::make_unique<flutter::MethodResultFunctions<flutter::EncodableValue>>(
29
          // Success callback: Dart returned {"Passphrase": "s3cr3t"}
30
          [promise](const flutter::EncodableValue* success) {
31
            std::map<std::string, sdbus::Variant> result;
32
            if (success &&
33
                std::holds_alternative<flutter::EncodableMap>(*success)) {
34
              for (const auto& kv :
35
                   std::get<flutter::EncodableMap>(*success)) {
36
                if (std::holds_alternative<std::string>(kv.first) &&
37
                    std::holds_alternative<std::string>(kv.second)) {
38
                  result[std::get<std::string>(kv.first)] =
39
                      sdbus::Variant(std::get<std::string>(kv.second));
40
                }
41
              }
42
              promise->set_value(std::move(result));
43
            } else {
44
              // No result? Treat as cancelled.
45
              promise->set_exception(std::make_exception_ptr(sdbus::Error(
46
                  sdbus::Error::Name("net.connman.Agent.Error.Canceled"),
47
                  "User canceled input request")));
48
            }
49
          },
50
          // Error callback: user cancelled or dialog failed
51
          [promise](const std::string& /*code*/, const std::string& msg,
52
                    const flutter::EncodableValue* /*details*/) {
53
            promise->set_exception(std::make_exception_ptr(sdbus::Error(
54
                sdbus::Error::Name("net.connman.Agent.Error.Canceled"), msg)));
55
          },
56
          // NotImplemented
57
          [promise]() {
58
            promise->set_exception(std::make_exception_ptr(sdbus::Error(
59
                sdbus::Error::Name("net.connman.Agent.Error.Canceled"),
60
                "requestInput not implemented")));
61
          }));
62

63
  // Step 4: Block the D-Bus thread until Dart responds.
64
  try {
65
    return future.get();
66
  } catch (const sdbus::Error&) {
67
    throw;  // Re-throw net.connman.Agent.Error.Canceled to ConnMan
68
  } catch (...) {
69
    throw sdbus::Error(
70
        sdbus::Error::Name("net.connman.Agent.Error.Canceled"),
71
        "Unknown error requesting input from Flutter");
72
  }
73
}

Note

The promise is a shared_ptr because the lambda callbacks extend their lifetime beyond the scope of RequestInput. The D-Bus thread holds a reference (through future.get()), and the Flutter platform thread holds another reference through the lambdas.

When the user cancels (taps Cancel in the dialog), the Dart side throws a PlatformException with code CANCELLED — this triggers the error callback, which sets an exception on the promise, causing future.get() to throw the sdbus::Error, which propagates back to ConnMan as an agent cancellation.

The Dart Side: ConnmanService

On the Flutter/Dart side, ConnmanService in lib/connman_service.dart handles the incoming requestInput call:

1
class ConnmanService {
2
  static const MethodChannel _channel = MethodChannel('io.github.jaydon2020');
3

4
  /// Set this callback before using ConnmanService.
5
  static Future<Map<String, String>?> Function(
6
    String service,
7
    List<String> fields,
8
  )? onRequestInput;
9

10
  static void init() {
11
    _channel.setMethodCallHandler(_handleMethodCall);
12
  }
13

14
  static Future<dynamic> _handleMethodCall(MethodCall call) async {
15
    if (call.method == 'requestInput') {
16
      final args = Map<String, dynamic>.from(call.arguments as Map);
17
      final service = args['service'] as String? ?? '';
18
      final fieldsMap = args['fields'] as Map? ?? {};
19
      final fields = fieldsMap.keys.cast<String>().toList();
20

21
      if (onRequestInput != null) {
22
        final result = await onRequestInput!(service, fields);
23
        if (result != null) {
24
          return result;  // {"Passphrase": "..."}
25
        }
26
      }
27
      // Returning null or throwing causes C++ to cancel.
28
      throw PlatformException(
29
        code: 'CANCELLED',
30
        message: 'User cancelled credential input',
31
      );
32
    }
33
    throw MissingPluginException('no handler for ${call.method}');
34
  }
35
}

The callback pattern (onRequestInput) decouples the service layer from the UI layer — the widget registers its dialog function, and the service calls it.

The Event-Driven Dart UI

The main WifiPage widget uses the EventChannel to receive live updates instead of polling:

1
@override
2
void initState() {
3
  super.initState();
4
  ConnmanService.onRequestInput = _showPasswordDialog;
5
  _initSystemWifi();
6
}
7

8
Future<void> _initSystemWifi() async {
9
  // Unblock the radio on AGL (rfkill may soft-block it by default)
10
  await Process.run('rfkill', ['unblock', 'wifi']);
11
  await Process.run('ip', ['link', 'set', 'wlan0', 'up']);
12

13
  // Subscribe BEFORE the first poll to avoid missing events
14
  _eventSub = _eventChannel.receiveBroadcastStream().listen(_onEvent);
15

16
  await _refreshWifiStatus();
17
}
18

19
void _onEvent(dynamic raw) {
20
  if (raw is! Map) return;
21
  final event = Map<String, dynamic>.from(raw);
22
  final type = event['type'] as String? ?? '';
23

24
  if (type == 'servicesChanged') {
25
    final rawList = event['services'] as List? ?? [];
26
    setState(() {
27
      _isBusy = false;
28
      _wifiServices = rawList
29
          .map((e) => Map<String, dynamic>.from(e as Map))
30
          .toList();
31
      _isConnected = _wifiServices
32
          .any((s) => s['state'] == 'ready' || s['state'] == 'online');
33
    });
34
  } else if (type == 'technologyChanged') {
35
    setState(() {
36
      _isBusy = false;
37
      if (event['powered'] != null) _isWifiPowered = event['powered'] as bool;
38
      if (event['connected'] != null) _isConnected = event['connected'] as bool;
39
      if (!_isWifiPowered) _wifiServices = [];
40
    });
41
  }
42
}

Article Series Roadmap

Part	Topic
Part 1	AGL architecture overview, ConnMan D-Bus API, plugin design
Part 2	Plugin registration, MethodChannel dispatch, EventChannel wiring in C++
Part 3	D-Bus operations: Technology and Service modules with sdbus-c++
Part 4 (this article)	The ConnMan Agent: bridging D-Bus callbacks to Flutter dialogs

Across this four-part series we’ve covered the complete implementation of a ConnMan Flutter plugin for AGL ivi-homescreen:

Thin dispatcher — connman_plugin.cc owns channels and routing; D-Bus logic is encapsulated in dedicated modules.
Background threads — blocking D-Bus calls (Connect, Scan, SetProperty) run on detached threads to keep the Flutter platform thread responsive.
Event-driven — D-Bus PropertyChanged and ServicesChanged signals drive UI updates; no polling needed.
Promise/future bridge — enables synchronous D-Bus callbacks to cross thread boundaries safely to a Flutter dialog.