Catching a signal asynchronously

[emilcarr]

Hello,

First of all forgive me for asking such a likely simple question. This is my first time working with dbus, and this library.

I am having trouble receiving a signal from an interface on the dbus.

I am trying to use the org.gnome.Mutter.ScreenCast bus to open a ScreenCast stream and listen for the pipewire port number it provides. The process should be as follows:

• Connect to org.gnome.Mutter.ScreenCast dbus
• Invoke CreateSession and receive the returned org.gnome.Mutter.ScreenCast.Session object path
• Invoke Session.[one of RecordMonitor, RecordWindow, RecordArea] and receive the returned org.gnome.Mutter.ScreenCast.Stream object path
• Invoke Session.Start and listen for the Stream.PipeWireStreamAdded signal to receive a pipewire node id.

You can see the documentation for this bus here

I am able to invoke each function and receive the object paths successfully. The signal I am looking for appears in dbus-monitor --session:

>>> The listener for the signal is created successfully
method call time=1616264584.596550 sender=:1.176 -> destination=org.freedesktop.DBus serial=5 path=/org/freedesktop/DBus; interface=org.freedesktop.DBus; member=AddMatch
   string "type='signal',interface='org.gnome.Mutter.ScreenCast.Stream',member='PipeWireStreamAdded',path='/org/gnome/Mutter/ScreenCast/Stream/u32'"
method return time=1616264584.596562 sender=org.freedesktop.DBus -> destination=:1.176 serial=3 reply_serial=5

>>> The session is started
method call time=1616264584.596617 sender=:1.176 -> destination=org.gnome.Mutter.ScreenCast serial=6 path=/org/gnome/Mutter/ScreenCast/Session/u37; interface=org.gnome.Mutter.ScreenCast.Session; member=Start
method return time=1616264584.599716 sender=:1.13 -> destination=:1.176 serial=3179 reply_serial=6

>>> The signal is sent over dbus
signal time=1616264584.601025 sender=:1.13 -> destination=:1.176 serial=3180 path=/org/gnome/Mutter/ScreenCast
/Stream/u32; interface=org.gnome.Mutter.ScreenCast.Stream; member=PipeWireStreamAdded
   uint32 57

However it is not received by my program:

void start_session() {

    const char* bus_name = "org.gnome.Mutter.ScreenCast";
    const char* object_path = "/org/gnome/Mutter/ScreenCast";
    
    auto connection = sdbus::createSessionBusConnection();
    auto screencast_proxy = sdbus::createProxy(*connection, bus_name, object_path);

    printf("dbus connected\n");    

    int version = screencast_proxy->getProperty("Version")
        .onInterface("org.gnome.Mutter.ScreenCast");
    printf("version: %i\n", version);

    // Create a session and receive its object path
    sdbus::ObjectPath session_path;
    screencast_proxy->callMethod("CreateSession")
        .onInterface("org.gnome.Mutter.ScreenCast")
        .withArguments(std::map<std::string, sdbus::Variant>{ 
                {"dummy", 0} 
            })
        .storeResultsTo(session_path);

    printf("session path: %s\n", session_path.c_str());

    // Open the Session object path
    session_proxy = sdbus::createProxy(*connection, bus_name, session_path);

    // Invoke RecordMonitor and receive the returned Stream object path
    sdbus::ObjectPath stream_path;
    session_proxy->callMethod("RecordMonitor")
        .onInterface("org.gnome.Mutter.ScreenCast.Session")
        .withArguments(
                "",
                std::map<std::string, sdbus::Variant>{
                    {"cursor-mode", 0}, // 0: hidden 1: embedded in framebuffer 2: included in metadata
                    {"is-recording", true}
                }
            )
        .storeResultsTo(stream_path);
    printf("stream path: %s\n", stream_path.c_str());

    // Open the Stream object path
    stream_proxy = sdbus::createProxy(*connection, bus_name, stream_path);

    // subscribe for PipeWireStreamAdded signal
    stream_proxy->uponSignal("PipeWireStreamAdded")
        .onInterface("org.gnome.Mutter.ScreenCast.Stream")
        .call([](uint32_t& node_id){ printf("SIGNAL. RECEIVED. node_id:%i\n", node_id); });
    session.stream_proxy->finishRegistration();

    printf("registered PipeWireStreamAdded signal callback\n");
    
    // Start the session. The PipeWireStreamAdded signal is sent after this.
    session.session_proxy->callMethod("Start").onInterface("org.gnome.Mutter.ScreenCast.Session");
    printf("started screen cast session\n");
    
    while(1); // don't exit
}

Expected behaviour: Program should print "started screen cast session" followed by "SIGNAL RECEIVED. node_id: [some uitn32_t]" upon receiving the signal.

Actual behaviour: Program prints "started screen cast session". Signal appears in dbus-monitor. No further output.

Can anybody see what I am doing wrong? I suspect perhaps I need to be using an event loop - however I can't figure out how to start the event loop to listen for the signal before invoking the ScreenCast.Session.Start method (in another thread?)

Cheers.

[emilcarr]

To answer my own question...

As I hinted at in my question, the solution is to subscribe to the signal and enter the event loop in a new thread:

    std::thread signal_thread ([&connection, bus_name, stream_path](){
        stream_proxy = sdbus::createProxy(*connection, bus_name, stream_path);
        // subscribe for PipeWireStreamAdded signal
        stream_proxy->uponSignal("PipeWireStreamAdded")
            .onInterface("org.gnome.Mutter.ScreenCast.Stream")
            .call([&session](uint32_t& node_id){ 
                    printf("SIGNAL. RECEIVED.%i\n", node_id);
                    connection->leaveEventLoop(); // we only needed this one signal. we can leave now.
                });
        session.stream_proxy->finishRegistration();

        connection->enterEventLoop();
    });

    printf("registered PipeWireStreamAdded signal callback\n");

    session.session_proxy->callMethod("Start").onInterface("org.gnome.Mutter.ScreenCast.Session");
    printf("started screen cast session\n");

    signal_thread.join(); // wait until we know the node id

Hopefully this can help someone else out.... Took me longer than it should have to figure it out!

[sangelovic]

As you've realized, you have to run an event loop on the connection you've created. So that the signals are listened to. Your solution is unnecessarily complex, I think. In your original example, instead of while(1);, you simply can do this at the end of main:

    ...
    connection->enterEventLoop();
}

and add command to stop the event loop: connection->leaveEventLoop(); at the end of your PipeWireStreamAdded signal handler. There should be no need to mess with threads and their synchronization in this simple case.

More info on the use of connections (and implicit/explicit event threads and loops) on client side: https://github.com/Kistler-Group/sdbus-cpp/blob/master/docs/using-sdbus-c++.md#using-d-bus-connections-on-the-client-side

[emilcarr]

Thanks for the extra info @sangelovic . The issue here in my specific case, is that the signal I need to listen for is sent after the "Start" method is invoked - the enterEventLoop() function prevents the code from advancing on to the next line where the Start method is invoked - which is why I added it to a separate thread.

[emilcarr]

I've just seen the enterEventLoopAsync() function - looks like it's what I need here. I'll give that a go at some point.

[sangelovic]

The issue here in my specific case, is that the signal I need to listen for is sent after the "Start" method is invoked

Yes, I understand. Perhaps I wasn't clear enough -- I meant you can replace last line (which is while(1); // don't exit (in your first example), or signal_thread.join();, respectively, in the second example) with connection->enterEventLoop();. "Start" invocation is before it, so it will be invoked. Then the main thread will block (without eating your CPU at 100%, as opposed to while(1);), waiting for incoming D-Bus message. When the signal comes, the main thread will invoke the signal handler. This one will unblock the loop, and the thread will jump out of enterEventLoop(), proceeding to the end of your program run.