/src/Widgets/ZoneOutputRow.vala at 7bd484b9a360004dd7498228fd4432a3651f4099

// 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 PlacGtkAdwaita {
	private errordomain ZoneOutputRowError {
		CHANGE_VOLUME_FAILED,
		STEP_VOLUME_FAILED,
	}

	private enum ZoneOutputRowVolumeStepDirection {
		INCREASE,
		DECREASE,
	}

	[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/zone-output-row.ui")]
	class ZoneOutputRow : Gtk.ListBoxRow {
		[GtkChild]
		private unowned Gtk.Label display_name;

		[GtkChild]
		private unowned Gtk.Box incremental_control;

		[GtkChild]
		private unowned Gtk.Box value_control;

		[GtkChild]
		private unowned Gtk.Scale volume_slider;

		[GtkChild]
		private unowned Gtk.Button volume_up_incr;

		[GtkChild]
		private unowned Gtk.Button volume_up;

		[GtkChild]
		private unowned Gtk.Button volume_down_incr;

		[GtkChild]
		private unowned Gtk.Button volume_down;

		public bool stale = false;

		public string output_id {
			get { return _output.output_id; }
		}

		public Plac.V2.Connection? conn { get; set construct; }

		private Roon.Transport.Output _output;
		public Roon.Transport.Output output {
			get { return _output; }
			set construct {
				_output = value;
				display_name.label = value.display_name;
				if (value.volume == null) {
					incremental_control.visible = false;
					value_control.visible = false;
					return;
				}

				if (value.volume.type == "incremental") {
					incremental_control.visible = true;
					value_control.visible = false;
				} else {
					incremental_control.visible = false;
					value_control.visible = true;
					if (volume_slider.adjustment.lower != value.volume.min) {
						volume_slider.adjustment.lower = value.volume.min;
					}
					if (volume_slider.adjustment.upper != value.volume.max) {
						volume_slider.adjustment.upper = value.volume.max;
					}
					if (!is_moving_volume && volume_slider.adjustment.value != value.volume.value) {
						volume_slider.adjustment.value = value.volume.value;
					}
					if (volume_slider.adjustment.step_increment != value.volume.step) {
						volume_slider.adjustment.step_increment = value.volume.step;
					}
				}
			}
		}

		private bool is_incrementing_volume = false;

		// true = increase, false = decrease
		private Gee.ArrayQueue<ZoneOutputRowVolumeStepDirection>volume_increment_queue =
			new Gee.ArrayQueue<ZoneOutputRowVolumeStepDirection>();

		private bool is_moving_volume = false;
		private double? next_volume_move_to = null;

		public ZoneOutputRow(Roon.Transport.Output output) {
			Object(output: output);
		}

		construct {
			volume_up_incr.clicked.connect(() => {
				queue_incremental_volume_change(INCREASE);
			});

			volume_up.clicked.connect(() => {
				queue_incremental_volume_change(INCREASE);
			});

			volume_down_incr.clicked.connect(() => {
				queue_incremental_volume_change(DECREASE);
			});

			volume_down.clicked.connect(() => {
				queue_incremental_volume_change(DECREASE);
			});

			volume_slider.change_value.connect((scroll, value) => {
				schedule_volume_change(value);
				return false;
			});
		}

		private void queue_incremental_volume_change(ZoneOutputRowVolumeStepDirection direction) {
			volume_increment_queue.offer(direction);

			if (!is_incrementing_volume) {
				is_incrementing_volume = true;
				dequeue_incremental_volume_change();
			}
		}

		private void dequeue_incremental_volume_change() {
			if (conn == null || volume_increment_queue.is_empty) {
				is_incrementing_volume = false;
				return;
			}

			var next = volume_increment_queue.poll();

			step_volume_async.begin(conn, next, (_obj, res) => {
				try {
					step_volume_async.end(res);
				} catch (GLib.Error error) {
					var label = next == INCREASE ? "Increase" : "Decrease";
					GLib.log("Plac", LEVEL_WARNING, "%s volume failed: %s", label, error.message);
				}

				dequeue_incremental_volume_change();
			});
		}

		private void schedule_volume_change(double value) {
			next_volume_move_to = value;

			if (!is_moving_volume) {
				is_moving_volume = true;
				take_volume_change();
			}
		}

		private void take_volume_change() {
			if (conn == null || next_volume_move_to == null) {
				is_moving_volume = false;
				return;
			}

			var value = next_volume_move_to;
			next_volume_move_to = null;

			change_volume_async.begin(conn, value, (_obj, res) => {
				try {
					change_volume_async.end(res);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_WARNING, "Volume change failed: %s", error.message);
				}

				take_volume_change();
			});
		}

		private async void change_volume_async(Plac.V2.Connection conn, double value) throws GLib.Error {
			var req = new Roon.Transport.ChangeVolume.Request(output.output_id);
			req.how = ABSOLUTE;
			req.value = value;

			var res = yield conn.json_request("com.roonlabs.transport:2/change_volume", req.to_json());
			if (res.meta.service != "Success") {
				throw new ZoneOutputRowError.CHANGE_VOLUME_FAILED(@"Expected Success response, got $(res.meta.service).");
			}
		}

		private async void step_volume_async(
			Plac.V2.Connection conn, ZoneOutputRowVolumeStepDirection direction
		) throws GLib.Error {
			double step = output.volume == null || output.volume.type == "incremental" ? 1.0 : output.volume.step;

			var req = new Roon.Transport.ChangeVolume.Request(output.output_id);
			req.how = RELATIVE;
			req.value = (direction == INCREASE ? 1.0 : -1.0) * step;

			var res = yield conn.json_request("com.roonlabs.transport:2/change_volume", req.to_json());
			if (res.meta.service != "Success") {
				throw new ZoneOutputRowError.STEP_VOLUME_FAILED(@"Expected Success response, got $(res.meta.service).");
			}
		}
	}
}