gtk-adwaita: Connect to server directly via IP address and port UDP multicast/broadcast is unreliable, especially in my environment where Roon server (or the machine hosting it) randomly stops responding to discovery query. Direct connection is really instant and I believe this would improve normal UX too.

Changes

8 changed files (+123/-1)

• core/src/discovery.zig
  • @@ -40,6 +40,7 @@ internal: *Internal,
    id: [*:0]const u8, name: [*:0]const u8, version: [*:0]const u8, + ip_addr: [*:0]const u8, http_port: u16, pub const Internal = struct {
  • @@ -63,6 +64,17 @@
    const version = try allocator.dupeZ(u8, resp.display_version); errdefer allocator.free(version); + var ip_addr_buf = std.ArrayList(u8).init(allocator); + defer ip_addr_buf.deinit(); + + try std.fmt.format(ip_addr_buf.writer(), "{}", .{addr}); + if (std.mem.lastIndexOfScalar(u8, ip_addr_buf.items, ':')) |last_colon| { + ip_addr_buf.shrinkAndFree(last_colon); + } + + const ip_addr = try allocator.dupeZ(u8, ip_addr_buf.items); + errdefer allocator.free(ip_addr); + var address = addr.*; address.setPort(resp.http_port);
  • @@ -75,6 +87,7 @@ .internal = internal,
    .id = id.ptr, .name = name.ptr, .version = version.ptr, + .ip_addr = ip_addr.ptr, .http_port = resp.http_port, };
  • @@ -102,6 +115,7 @@
    allocator.free(std.mem.span(self.id)); allocator.free(std.mem.span(self.name)); allocator.free(std.mem.span(self.version)); + allocator.free(std.mem.span(self.ip_addr)); allocator.destroy(self.internal); allocator.destroy(self); }
• core/src/plac.h
  • @@ -35,6 +35,7 @@ void *__pri;
    char *id; char *name; char *version; + char *ip_addr; uint16_t http_port; } plac_discovery_server; plac_discovery_server *plac_discovery_server_retain(plac_discovery_server*);
• core/src/plac.vapi
  • @@ -33,6 +33,7 @@
    public string id; public string name; public string version; + public string ip_addr; public uint16 http_port; }
• gtk-adwaita/data/jp.pocka.plac.gtk-adwaita.gschema.xml
  • @@ -28,6 +28,16 @@ <default>""</default>
    <summary>Last Connected Server Token</summary> <description>Connects to the server with this token. Ignored when connected-server-id is empty.</description> </key> + <key name="connected-server-addr" type="s"> + <default>""</default> + <summary>Last Connected Server IP Address</summary> + <description>Connects to the server at this address. Ignored when connected-server-id is empty.</description> + </key> + <key name="connected-server-port" type="u"> + <default>9330</default> + <summary>Last Connected Server IP Address</summary> + <description>TCP port number to use when connecting to server using connected-server-addr.</description> + </key> <key name="label-parsing-enabled" type="b"> <default>true</default> <summary>Enable label parsing</summary>
• gtk-adwaita/src/Application.vala
  • @@ -46,7 +46,14 @@ var selector = new ServerSelector.Window(this);
    selector.start(); } else { var main_window = new MainWindow.from_server_id(this, settings.connected_server_id); - main_window.start(); + if (settings.connected_server_addr != "" && settings.connected_server_port > 0) { + main_window.start_with_addr( + settings.connected_server_addr, + settings.connected_server_port + ); + } else { + main_window.start(); + } } }
• gtk-adwaita/src/Plac.vala
  • @@ -41,6 +41,19 @@
    yield; return (owned) result; } + + public async Plac.Discovery.ScanResult? resolve_async(string server_id, string ip_addr, uint16 http_port) { + GLib.SourceFunc callback = resolve_async.callback; + Plac.Discovery.ScanResult? result = null; + + new GLib.Thread<void>("server-resolve", () => { + result = Plac.Discovery.resolve(server_id, ip_addr, http_port); + GLib.Idle.add((owned) callback); + }); + + yield; + return (owned) result; + } } public class AsyncConnection : GLib.Object {
• gtk-adwaita/src/Settings.vala
  • @@ -17,6 +17,8 @@
    namespace PlacGtkAdwaita { private const string CONNECTED_SERVER_ID = "connected-server-id"; private const string CONNECTED_SERVER_TOKEN = "connected-server-token"; + private const string CONNECTED_SERVER_ADDR = "connected-server-addr"; + private const string CONNECTED_SERVER_PORT = "connected-server-port"; public class Settings { public const string LABEL_PARSING_ENABLED = "label-parsing-enabled";
  • @@ -36,6 +38,16 @@
    public string connected_server_token { owned get { return settings.get_string(CONNECTED_SERVER_TOKEN); } set { settings.set_string(CONNECTED_SERVER_TOKEN, value); } + } + + public string connected_server_addr { + owned get { return settings.get_string(CONNECTED_SERVER_ADDR); } + set { settings.set_string(CONNECTED_SERVER_ADDR, value); } + } + + public uint16 connected_server_port { + owned get { return (uint16) settings.get_uint(CONNECTED_SERVER_PORT); } + set { settings.set_uint(CONNECTED_SERVER_PORT, value); } } public bool label_parsing_enabled {
• gtk-adwaita/src/Windows/MainWindow.vala
  • @@ -117,6 +117,14 @@
    this.present(); } + public void start_with_addr(string ip_addr, uint16 port) { + root_stack.visible_child_name = "loading"; + + try_listen_with_addr(ip_addr, port); + + this.present(); + } + private void try_listen() { error_banner.revealed = false;
  • @@ -137,6 +145,25 @@ });
    } } + private void try_listen_with_addr(string ip_addr, uint16 port) { + if (conn != null) { + listen_events(); + return; + } + + resolve_server_with_addr.begin(ip_addr, port, (obj, res) => { + try { + resolve_server_with_addr.end(res); + } catch (ResolveError e) { + GLib.log("Plac", LEVEL_INFO, "Failed to restore connection, scanning server"); + try_listen(); + return; + } + + listen_events(); + }); + } + private void listen_events() { this.title = "Plac - %s".printf(server.name);
  • @@ -151,6 +178,8 @@ playback_toolbar.visible = true;
    settings.connected_server_id = server_id; settings.connected_server_token = event.token; + settings.connected_server_addr = server.ip_addr; + settings.connected_server_port = server.http_port; browse.start(conn); });
  • @@ -188,6 +217,41 @@ }
    if (result.servers.length < 1) { GLib.log("Plac", LEVEL_CRITICAL, "Server not found: ID=%s", server_id); + Idle.add((owned) callback); + error = new ResolveError.SERVER_NOT_FOUND("Server not found"); + return; + } + + server = result.servers[0]; + conn = new Plac.AsyncConnection.with_token(server, settings.connected_server_token); + Idle.add((owned) callback); + }); + + yield; + + if (error != null) { + throw error; + } + } + + private async void resolve_server_with_addr(string ip_addr, uint16 http_port) throws ResolveError { + GLib.SourceFunc callback = resolve_server_with_addr.callback; + ResolveError? error = null; + + Plac.Discovery.resolve_async.begin(server_id, ip_addr, http_port, (obj, res) => { + var result = Plac.Discovery.resolve_async.end(res); + + if (result.code != OK) { + GLib.log("Plac", LEVEL_INFO, "Failed to connect to server at %s:%u: %s", + ip_addr, http_port, result.code.to_string()); + Idle.add((owned) callback); + error = new ResolveError.CONNECTION_ERROR("Failed to connect: %s".printf(result.code.to_string())); + return; + } + + if (result.servers.length < 1) { + GLib.log("Plac", LEVEL_CRITICAL, "Server not found at %s:%u: ID=%s", + ip_addr, http_port, server_id); Idle.add((owned) callback); error = new ResolveError.SERVER_NOT_FOUND("Server not found"); return;