/src/Plac/ZonesModel.vala at 28bbf5cf74c5ddcfe65327caf510be1b103cbaf9

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

namespace Plac {
	public errordomain ZonesModelError {
		SUBSCRIPTION_FAILED,
	}

	public class ZoneModel : Object {
		public Roon.Transport.Zone zone { get; set construct; }

		public ZoneModel(Roon.Transport.Zone zone) {
			Object(zone: zone);
		}

		public static bool is_same_zone(ZoneModel a, ZoneModel b) {
			return a.zone.zone_id == b.zone.zone_id;
		}
	}

	public class ZonesModel : Object {
		public signal void added(Roon.Transport.Zone zone);
		public signal void changed(Roon.Transport.Zone zone);
		public signal void removed(Roon.Transport.Zone zone);
		public signal void seek(Roon.Transport.SeekChange change);
		public signal void error(GLib.Error error);

		public Connection conn { get; set construct; }

		public GLib.ListStore zones {
			get; construct;
		}

		private uint zone_position = 0;
		public ZoneModel? zone {
			owned get {
				return (ZoneModel?) zones.get_item(zone_position);
			}

			set {
				uint position;
				if (zones.find_with_equal_func(value, (GLib.EqualFunc<ZoneModel>) ZoneModel.is_same_zone, out position)) {
					zone_position = position;
				}
			}
		}

		public ZonesModel(Connection conn) {
			Object(conn: conn, zones: new GLib.ListStore(typeof (ZoneModel)));
		}

		construct {
			this.notify["conn"].connect(() => {
				this.listen_changes();
			});

			this.listen_changes();
		}

		private void listen_changes() {
			this.zones.remove_all();

			this.listen_changes_async.begin((obj, res) => {
				try {
					this.listen_changes_async.end(res);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_CRITICAL, "Failed to subscribe to zone changes: %s", error.message);
				}
			});
		}

		private async void listen_changes_async() throws GLib.Error {
			GLib.log("Plac", LEVEL_DEBUG, "Subscribing to zone changes...");

			var req = new Roon.Transport.SubscribeZoneChanges.Request("1");

			var res = yield conn.json_request("com.roonlabs.transport:2/subscribe_zones", req.to_json());
			if (res.meta.service != "Subscribed") {
				throw new ZonesModelError.SUBSCRIPTION_FAILED(@"Expected Subscribed, got \"$(res.meta.service)\"");
			}

			var body = new Moo.JsonBody.from_string(res.message, res.headers);
			var result = new Roon.Transport.SubscribeZoneChanges.Response.from_json(body.data);

			if (result == null) {
				throw new ZonesModelError.SUBSCRIPTION_FAILED("Got invalid subscription response.");
			}

			foreach (var zone in result.zones) {
				var model = new ZoneModel(zone);
				zones.append(model);
				if (this.zone == null) {
					this.zone = model;
				}
			}

			GLib.log("Plac", LEVEL_DEBUG, "Subscribed successfully, found %u initial.", zones.n_items);

			conn.conn.message.connect((_conn, _type, bytes) => {
				var message = (string) bytes.get_data();

				Moo.Metadata meta;
				Moo.Headers headers;
				try {
					meta = new Moo.Metadata.from_string(message);
					headers = new Moo.Headers.from_string(message, meta);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_WARNING, "Got invalid MOO message: %s", error.message);
					return;
				}

				if (meta.service != "Changed" || headers.request_id != res.headers.request_id) {
					return;
				}

				Roon.Transport.SubscribeZoneChanges.Event event;
				try {
					var event_body = new Moo.JsonBody.from_string(message, headers);
					event = new Roon.Transport.SubscribeZoneChanges.Event.from_json(event_body.data);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_WARNING, "Got unparsable zone change event: %s", error.message);
					return;
				}

				foreach (var id in event.removed_zone_ids) {
					for (uint i = 0; i < zones.n_items; i++) {
						var model = (ZoneModel) zones.get_item(i);
						if (model.zone.zone_id == id) {
							GLib.log("Plac", LEVEL_DEBUG, "Zone removed: %s", model.zone.display_name);
							zones.remove(i);
							this.removed(model.zone);
							break;
						}
					}
				}

				foreach (var added in event.added_zones) {
					var new_model = new ZoneModel(added);

					// Roon behaves pretty badly in state updates: they send
					// an "added" event initially. Subscribe method's response
					// already contains those zones.
					uint position;
					if (zones.find_with_equal_func(new_model, (GLib.EqualFunc<ZoneModel>) ZoneModel.is_same_zone, out position)) {
						var model = (ZoneModel) zones.get_item(position);
						model.zone = added;
						this.changed(added);
					} else {
						GLib.log("Plac", LEVEL_DEBUG, "New zone added: %s", added.display_name);
						zones.append(new_model);
						this.added(added);
					}
				}

				foreach (var changed in event.changed_zones) {
					var new_model = new ZoneModel(changed);

					// We might have missed an "added" event, so make sure
					// we safely handle change events to unknown zones.
					uint position;
					if (zones.find_with_equal_func(new_model, (GLib.EqualFunc<ZoneModel>) ZoneModel.is_same_zone, out position)) {
						var model = (ZoneModel) zones.get_item(position);
						model.zone = changed;
						this.changed(changed);
					} else {
						GLib.log("Plac", LEVEL_DEBUG, "New zone added by change event: %s", changed.display_name);
						zones.append(new_model);
						this.added(changed);
					}
				}

				foreach (var seek_change in event.seek_changes) {
					for (uint i = 0; i < zones.n_items; i++) {
						var model = (ZoneModel) zones.get_item(i);
						if (model.zone.zone_id == seek_change.zone_id && model.zone.now_playing != null) {
							if (seek_change.has_seek_position) {
								model.zone.now_playing.has_seek_position = true;
								model.zone.now_playing.seek_position = seek_change.seek_position;
							} else {
								model.zone.now_playing.has_seek_position = false;
							}
							this.seek(seek_change);
							break;
						}
					}
				}
			});
		}
	}
}