ekklesiaandClaude Opus 5
a5c7d1d057
Taking the launcher off the bar is half of a feature switch. The command has to refuse as well, or a device that does not offer an application can still be talked into running it by a stale desktop entry, a leftover window rule or a technician's muscle memory. Wonder Ink already did this. Parent Call now does the same, through the same helper and with the same default: absent means yes, so every existing room is unaffected. Co-Authored-By: Claude Opus 5 <[email protected]>
850 lines
30 KiB
Python
Executable File
850 lines
30 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""Ask the sanctuary to call a child's parent.
|
|
|
|
A quick action, not an application. The panel launches this, it puts one
|
|
small card on the screen, and it goes away again. Everything it knows
|
|
about the church end comes from the Parent Call coordinator's own MQTT
|
|
contract; see classroom_parent_call for the contract itself.
|
|
|
|
Why this is a separate process, and not a Plasma applet:
|
|
|
|
the panel is the only way a teacher has of getting anywhere, and a
|
|
broker library, a network timeout and a text entry have no business
|
|
living inside it. If this crashes, the bar is untouched and clicking
|
|
the button again starts a new one.
|
|
|
|
Two rules it will not bend:
|
|
|
|
* a teacher is never told a call succeeded unless the coordinator
|
|
said so, and the strongest thing the coordinator ever says is
|
|
"Sent to sanctuary" — never "displayed";
|
|
* nothing is published until the status topic for that request is
|
|
already subscribed, so an answer cannot arrive before anyone is
|
|
listening.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import threading
|
|
import time
|
|
|
|
import gi
|
|
|
|
gi.require_version("Gtk", "3.0")
|
|
# Gdk has to be pinned too. Without it PyGObject warns that it may load a
|
|
# different major version than Gtk, and the key constants this file
|
|
# compares against would then be somebody else's.
|
|
gi.require_version("Gdk", "3.0")
|
|
|
|
from gi.repository import Gdk, GLib, Gtk # noqa: E402
|
|
|
|
# Where the card sits on the screen.
|
|
#
|
|
# A Wayland client cannot place its own window, and the card used to be
|
|
# centred because KWin centres everything. On a classroom television that
|
|
# puts it in the middle of whatever the room is watching, a long way from
|
|
# the button that opened it. Layer shell is the compositor's own answer:
|
|
# the surface is anchored to an edge and the compositor does the
|
|
# arithmetic, so bottom-left is bottom-left at 1080p and at 4K, at 100%
|
|
# and at 200%, with no coordinates written down anywhere.
|
|
#
|
|
# The classroom already draws the disc player's cover and control bar
|
|
# this way under KWin, so the mechanism is one this room has run for
|
|
# months rather than a new dependency.
|
|
#
|
|
# Optional on purpose. If the library is missing the card still opens,
|
|
# centred, exactly as it did before: a teacher can always reach it.
|
|
try:
|
|
gi.require_version("GtkLayerShell", "0.1")
|
|
from gi.repository import GtkLayerShell # noqa: E402
|
|
except (ImportError, ValueError):
|
|
GtkLayerShell = None
|
|
|
|
# Logical pixels, so they mean the same thing at every scale.
|
|
#
|
|
# The bar is 76 logical pixels tall and reserves that space, so the
|
|
# compositor already keeps a bottom-anchored surface clear of it; this
|
|
# gap is the breathing room above it. The left margin lines the card up
|
|
# near the launcher that opened it rather than hard against the edge.
|
|
CARD_GAP_BOTTOM = 16
|
|
CARD_GAP_LEFT = 16
|
|
|
|
sys.path.insert(0, "/usr/local/lib/ekklesia-classroom")
|
|
sys.path.insert(
|
|
0,
|
|
os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "lib"),
|
|
)
|
|
|
|
import classroom_parent_call as contract # noqa: E402
|
|
from classroom_config import feature, read_device_config # noqa: E402
|
|
from classroom_mqtt import room_name # noqa: E402
|
|
|
|
APP_ID = "classroom-parent-call"
|
|
|
|
# How long to wait for the broker before telling the teacher the church
|
|
# network cannot be reached. Short: a teacher standing at the machine
|
|
# would rather be told quickly than watch a spinner.
|
|
CONNECT_TIMEOUT = 5.0
|
|
|
|
# Retained topics arrive immediately after subscribing, or never. This is
|
|
# how long "never" takes to establish.
|
|
RETAINED_GRACE = 1.5
|
|
|
|
# The coordinator answers a request almost at once. Silence for this long
|
|
# means it did not hear us, which is not the same as a refusal and is not
|
|
# reported as one.
|
|
FIRST_STATUS_TIMEOUT = 8.0
|
|
|
|
# Once it has answered, it may legitimately take as long as its own
|
|
# request expiry to finish — an operator has to approve. Its REQUEST_TTL
|
|
# is 180s; this is that with room to spare.
|
|
OVERALL_TIMEOUT = 210.0
|
|
|
|
# Long enough for a teacher to read "Sent to sanctuary" and walk away.
|
|
CLOSE_AFTER_SUCCESS = 4.0
|
|
|
|
|
|
def load_colours():
|
|
"""The session's own palette, read from the colour scheme in use.
|
|
|
|
There is one set of design tokens in this classroom, and they live in
|
|
a Plasma colour scheme. Reading them here rather than repeating them
|
|
means this card follows classroom-theme light and dark without
|
|
knowing that either exists.
|
|
"""
|
|
palette = {
|
|
"window": "#141c20", "view": "#0f171a", "text": "#e6edef",
|
|
"dim": "#93a5aa", "accent": "#4fb3a8", "on_accent": "#0e1518",
|
|
"negative": "#e36a6a", "neutral": "#e0b15c", "positive": "#6fcf97",
|
|
"line": "#25333a",
|
|
}
|
|
|
|
scheme = "EkklesiaDark"
|
|
|
|
for path in (
|
|
os.path.expanduser("~/.config/kdeglobals"),
|
|
"/etc/ekklesia-classroom/xdg/kdeglobals",
|
|
"/etc/xdg/kdeglobals",
|
|
):
|
|
try:
|
|
with open(path, "r", encoding="utf-8") as handle:
|
|
section = None
|
|
for line in handle:
|
|
line = line.strip()
|
|
if line.startswith("["):
|
|
section = line
|
|
elif section and section.startswith("[General]") and \
|
|
line.startswith("ColorScheme="):
|
|
scheme = line.split("=", 1)[1].strip()
|
|
break
|
|
except OSError:
|
|
continue
|
|
else:
|
|
if scheme:
|
|
break
|
|
|
|
def rgb(value):
|
|
parts = [part.strip() for part in value.split(",")]
|
|
if len(parts) != 3:
|
|
return None
|
|
try:
|
|
return "#%02x%02x%02x" % tuple(int(part) for part in parts)
|
|
except ValueError:
|
|
return None
|
|
|
|
try:
|
|
with open(f"/usr/share/color-schemes/{scheme}.colors", "r",
|
|
encoding="utf-8") as handle:
|
|
group = None
|
|
for line in handle:
|
|
line = line.strip()
|
|
if line.startswith("["):
|
|
group = line
|
|
continue
|
|
if "=" not in line or group is None:
|
|
continue
|
|
key, value = (part.strip() for part in line.split("=", 1))
|
|
colour = rgb(value)
|
|
if colour is None:
|
|
continue
|
|
if group == "[Colors:Window]":
|
|
if key == "BackgroundNormal":
|
|
palette["window"] = colour
|
|
elif key == "ForegroundNormal":
|
|
palette["text"] = colour
|
|
elif key == "ForegroundInactive":
|
|
palette["dim"] = colour
|
|
elif key == "ForegroundNegative":
|
|
palette["negative"] = colour
|
|
elif key == "ForegroundNeutral":
|
|
palette["neutral"] = colour
|
|
elif key == "ForegroundPositive":
|
|
palette["positive"] = colour
|
|
elif key == "BackgroundAlternate":
|
|
palette["line"] = colour
|
|
elif group == "[Colors:View]" and key == "BackgroundNormal":
|
|
palette["view"] = colour
|
|
elif group == "[Colors:Selection]":
|
|
if key == "BackgroundNormal":
|
|
palette["accent"] = colour
|
|
elif key == "ForegroundNormal":
|
|
palette["on_accent"] = colour
|
|
except OSError:
|
|
pass
|
|
|
|
return palette
|
|
|
|
|
|
STYLE = """
|
|
* {{ font-family: "Noto Sans", "DejaVu Sans", sans-serif; }}
|
|
|
|
/* The card draws its own corners, so the window behind it is nothing at
|
|
all. Rounding a window any other way would mean asking the compositor
|
|
for something, and this one is ours to draw. */
|
|
window {{ background-color: transparent; }}
|
|
|
|
#card {{
|
|
background-color: {window};
|
|
border: 1px solid {line};
|
|
border-radius: 12px;
|
|
padding: 24px 26px 20px 26px;
|
|
margin: 10px;
|
|
}}
|
|
|
|
#title {{ color: {text}; font-size: 17px; font-weight: 600; }}
|
|
#room {{ color: {accent}; font-size: 13px; font-weight: 600;
|
|
letter-spacing: 0.06em; }}
|
|
#hint {{ color: {dim}; font-size: 12px; }}
|
|
#status {{ color: {text}; font-size: 15px; font-weight: 600; }}
|
|
#detail {{ color: {dim}; font-size: 12px; }}
|
|
#child {{ color: {dim}; font-size: 13px; }}
|
|
|
|
#status.good {{ color: {positive}; }}
|
|
#status.bad {{ color: {negative}; }}
|
|
#status.waiting {{ color: {neutral}; }}
|
|
|
|
entry {{
|
|
background-color: {view};
|
|
color: {text};
|
|
border: 1px solid {line};
|
|
border-radius: 8px;
|
|
padding: 10px 12px;
|
|
font-size: 16px;
|
|
caret-color: {accent};
|
|
}}
|
|
entry:focus {{ border-color: {accent}; }}
|
|
entry:disabled {{ color: {dim}; }}
|
|
|
|
button {{
|
|
border-radius: 8px;
|
|
padding: 9px 18px;
|
|
font-size: 14px;
|
|
font-weight: 600;
|
|
border: 1px solid {line};
|
|
background-image: none;
|
|
background-color: transparent;
|
|
color: {text};
|
|
}}
|
|
button:hover {{ background-color: {line}; }}
|
|
|
|
button#primary {{
|
|
background-color: {accent};
|
|
color: {on_accent};
|
|
border-color: {accent};
|
|
}}
|
|
/* Disabled has to read as "not yet", not as a broken button: the accent
|
|
drains out of it rather than the whole thing fading. */
|
|
button#primary:disabled {{
|
|
background-color: transparent;
|
|
color: {dim};
|
|
border-color: {line};
|
|
}}
|
|
"""
|
|
|
|
|
|
class Broker(threading.Thread):
|
|
"""The MQTT half, kept off the interface thread.
|
|
|
|
Every callback hands its result to GTK with GLib.idle_add and touches
|
|
no widget itself.
|
|
"""
|
|
|
|
def __init__(self, config, topics, on_event):
|
|
super().__init__(daemon=True)
|
|
self.config = config
|
|
self.topics = topics
|
|
self.on_event = on_event
|
|
self.client = None
|
|
self.request_id = None
|
|
self._pending = None
|
|
self._lock = threading.Lock()
|
|
|
|
# -- lifecycle -----------------------------------------------------
|
|
|
|
def run(self):
|
|
try:
|
|
import paho.mqtt.client as mqtt
|
|
except ImportError:
|
|
self.emit("broker", reachable=False, why="no broker library")
|
|
return
|
|
|
|
host = (self.config.get("MQTT_HOST") or "").strip()
|
|
|
|
if not host or (self.config.get("MQTT_ENABLED") or "").strip().lower() \
|
|
not in ("1", "true", "yes", "on"):
|
|
self.emit("broker", reachable=False, why="not configured")
|
|
return
|
|
|
|
try:
|
|
port = int((self.config.get("MQTT_PORT") or "1883").strip())
|
|
except ValueError:
|
|
port = 1883
|
|
|
|
# A clean session on purpose. Nothing from a previous connection
|
|
# may be redelivered: a parent call from last Sunday arriving now
|
|
# would be worse than one that was lost.
|
|
try:
|
|
client = mqtt.Client(
|
|
mqtt.CallbackAPIVersion.VERSION2,
|
|
client_id=f"classroom-parent-call-{os.getpid()}",
|
|
clean_session=True,
|
|
)
|
|
except (AttributeError, TypeError):
|
|
client = mqtt.Client(
|
|
client_id=f"classroom-parent-call-{os.getpid()}",
|
|
clean_session=True,
|
|
)
|
|
|
|
username = (self.config.get("MQTT_USERNAME") or "").strip()
|
|
|
|
if username:
|
|
client.username_pw_set(
|
|
username, (self.config.get("MQTT_PASSWORD") or "").strip() or None
|
|
)
|
|
|
|
client.on_connect = self._connected
|
|
client.on_message = self._message
|
|
client.on_disconnect = self._disconnected
|
|
|
|
self.client = client
|
|
|
|
try:
|
|
client.connect(host, port, keepalive=30)
|
|
except (OSError, ValueError) as error:
|
|
self.emit("broker", reachable=False, why=str(error))
|
|
return
|
|
|
|
client.loop_forever(retry_first_connection=False)
|
|
|
|
def stop(self):
|
|
client = self.client
|
|
|
|
if client is not None:
|
|
try:
|
|
client.disconnect()
|
|
except Exception:
|
|
pass
|
|
|
|
# -- callbacks -----------------------------------------------------
|
|
|
|
def _connected(self, client, userdata, flags, reason_code, properties=None):
|
|
if getattr(reason_code, "is_failure", False) or \
|
|
(isinstance(reason_code, int) and reason_code != 0):
|
|
self.emit("broker", reachable=False, why=f"refused ({reason_code})")
|
|
return
|
|
|
|
client.subscribe([(self.topics.mode, 1), (self.topics.coordinator, 1)])
|
|
self.emit("broker", reachable=True)
|
|
|
|
def _disconnected(self, client, userdata, *args):
|
|
self.emit("disconnected")
|
|
|
|
def _message(self, client, userdata, message):
|
|
if message.topic == self.topics.mode:
|
|
self.emit("mode", mode=contract.read_mode(message.payload))
|
|
elif message.topic == self.topics.coordinator:
|
|
self.emit("coordinator",
|
|
online=contract.read_coordinator(message.payload))
|
|
elif self.request_id and message.topic == self.topics.status(self.request_id):
|
|
update = contract.read_status(message.payload, self.request_id)
|
|
|
|
if update:
|
|
self.emit("status", update=update)
|
|
|
|
# -- sending -------------------------------------------------------
|
|
|
|
def send(self, request_id, room, child):
|
|
"""Subscribe first, publish second. Never the other way round."""
|
|
client = self.client
|
|
|
|
if client is None:
|
|
self.emit("send-failed", why="not connected")
|
|
return
|
|
|
|
with self._lock:
|
|
self.request_id = request_id
|
|
|
|
body = contract.request_payload(request_id, room, child)
|
|
|
|
import json
|
|
|
|
def after_subscribe(_client, _userdata, _mid, _codes, _properties=None):
|
|
# QoS 1 so the coordinator's answer is not lost on a flaky
|
|
# link, and never retained: a request is an event.
|
|
client.publish(self.topics.request, json.dumps(body), qos=1,
|
|
retain=False)
|
|
self.emit("published")
|
|
|
|
client.on_subscribe = after_subscribe
|
|
client.subscribe(self.topics.status(request_id), qos=1)
|
|
|
|
def emit(self, kind, **data):
|
|
GLib.idle_add(self.on_event, kind, data)
|
|
|
|
|
|
class ParentCall(Gtk.Window):
|
|
def __init__(self):
|
|
super().__init__(title="Parent Call")
|
|
|
|
self.config = read_device_config()
|
|
self.room = room_name(self.config)
|
|
self.topics = contract.Topics(
|
|
(self.config.get("PARENT_CALL_ROOT") or contract.DEFAULT_ROOT).strip()
|
|
)
|
|
|
|
self.mode = None
|
|
self.coordinator_online = False
|
|
self.broker_reachable = None
|
|
self.request_id = None
|
|
self.sent_at = None
|
|
self.settled = False
|
|
self.autosend = False
|
|
self._timers = []
|
|
|
|
self.set_decorated(False)
|
|
self.set_titlebar(Gtk.Box())
|
|
self.set_resizable(False)
|
|
self.set_default_size(460, -1)
|
|
self._anchor_bottom_left()
|
|
self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
|
|
# Belt and braces with the window rule: whichever of the two KWin
|
|
# honours, the card must not end up behind the lesson a teacher
|
|
# was reading when they pressed the button.
|
|
self.set_keep_above(True)
|
|
|
|
screen = self.get_screen()
|
|
visual = screen.get_rgba_visual()
|
|
|
|
if visual is not None:
|
|
self.set_visual(visual)
|
|
|
|
self.set_app_paintable(True)
|
|
|
|
self._build()
|
|
self._apply_style()
|
|
|
|
self.connect("key-press-event", self._key)
|
|
self.connect("destroy", lambda *_: self._quit())
|
|
|
|
self.broker = Broker(self.config, self.topics, self._event)
|
|
self.broker.start()
|
|
|
|
self._after(CONNECT_TIMEOUT, self._connect_deadline)
|
|
|
|
# -- interface -----------------------------------------------------
|
|
|
|
def _build(self):
|
|
card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
|
|
card.set_name("card")
|
|
|
|
heading = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
|
|
title = Gtk.Label(label="Parent Call", xalign=0)
|
|
title.set_name("title")
|
|
heading.pack_start(title, False, False, 0)
|
|
|
|
# The room is stated, never asked. This machine already knows
|
|
# which room it is, and a teacher picking it from a list is a
|
|
# chance to pick the wrong one.
|
|
room = Gtk.Label(label=self.room.upper(), xalign=0)
|
|
room.set_name("room")
|
|
room.set_valign(Gtk.Align.CENTER)
|
|
heading.pack_end(room, False, False, 0)
|
|
card.pack_start(heading, False, False, 0)
|
|
|
|
self.hint = Gtk.Label(
|
|
label="Who should we call a parent for?", xalign=0)
|
|
self.hint.set_name("hint")
|
|
card.pack_start(self.hint, False, False, 0)
|
|
|
|
self.entry = Gtk.Entry()
|
|
self.entry.set_placeholder_text("Child's name")
|
|
self.entry.set_max_length(contract.MAX_CHILD)
|
|
self.entry.set_sensitive(False)
|
|
self.entry.connect("activate", lambda *_: self._send())
|
|
self.entry.connect("changed", lambda *_: self._refresh_button())
|
|
card.pack_start(self.entry, False, False, 0)
|
|
|
|
self.status = Gtk.Label(label="", xalign=0)
|
|
self.status.set_name("status")
|
|
self.status.set_line_wrap(True)
|
|
self.status.set_no_show_all(True)
|
|
card.pack_start(self.status, False, False, 0)
|
|
|
|
self.detail = Gtk.Label(label="", xalign=0)
|
|
self.detail.set_name("detail")
|
|
self.detail.set_line_wrap(True)
|
|
self.detail.set_no_show_all(True)
|
|
card.pack_start(self.detail, False, False, 0)
|
|
|
|
buttons = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
|
|
buttons.set_halign(Gtk.Align.END)
|
|
|
|
self.close_button = Gtk.Button(label="Close")
|
|
self.close_button.connect("clicked", lambda *_: self._quit())
|
|
buttons.pack_start(self.close_button, False, False, 0)
|
|
|
|
self.primary = Gtk.Button(label="Call parent")
|
|
self.primary.set_name("primary")
|
|
self.primary.set_sensitive(False)
|
|
self.primary.connect("clicked", lambda *_: self._send())
|
|
buttons.pack_start(self.primary, False, False, 0)
|
|
|
|
card.pack_start(buttons, False, False, 0)
|
|
|
|
card.set_size_request(440, -1)
|
|
self.add(card)
|
|
card.show_all()
|
|
self.entry.grab_focus()
|
|
|
|
self._set_status("Checking with the sanctuary…", tone=None)
|
|
|
|
def _apply_style(self):
|
|
css = Gtk.CssProvider()
|
|
css.load_from_data(STYLE.format(**load_colours()).encode("utf-8"))
|
|
Gtk.StyleContext.add_provider_for_screen(
|
|
self.get_screen(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
|
|
)
|
|
|
|
def _anchor_bottom_left(self):
|
|
"""Put the card in the corner its launcher is in.
|
|
|
|
Anchored rather than positioned: the compositor is told which two
|
|
edges to hold the surface against and works the rest out itself,
|
|
so this is right on a 1080p television at 100% and on a 4K one at
|
|
200% without either number appearing here.
|
|
|
|
Keyboard interactivity is the part that matters and the part that
|
|
has to be asked for: a teacher types a child's name into this.
|
|
"""
|
|
if GtkLayerShell is None:
|
|
return
|
|
|
|
try:
|
|
GtkLayerShell.init_for_window(self)
|
|
# TOP, not OVERLAY. The disc player's cover is an overlay and
|
|
# is meant to be in front of everything including this; a
|
|
# teacher fetching a parent during a film is not a reason to
|
|
# put a text box over the film's own controls.
|
|
GtkLayerShell.set_layer(self, GtkLayerShell.Layer.TOP)
|
|
GtkLayerShell.set_anchor(self, GtkLayerShell.Edge.BOTTOM, True)
|
|
GtkLayerShell.set_anchor(self, GtkLayerShell.Edge.LEFT, True)
|
|
GtkLayerShell.set_margin(
|
|
self, GtkLayerShell.Edge.BOTTOM, CARD_GAP_BOTTOM)
|
|
GtkLayerShell.set_margin(
|
|
self, GtkLayerShell.Edge.LEFT, CARD_GAP_LEFT)
|
|
# Reserve nothing. The card is a moment, not furniture, and a
|
|
# surface that reserved space would push the lesson around
|
|
# every time somebody fetched a parent.
|
|
GtkLayerShell.set_exclusive_zone(self, 0)
|
|
GtkLayerShell.set_keyboard_interactivity(self, True)
|
|
except Exception as error: # noqa: BLE001
|
|
# Any failure here is cosmetic. A centred card a teacher can
|
|
# type into beats a perfectly placed one that never opened.
|
|
print(f"classroom-parent-call: layer shell unavailable: {error}",
|
|
file=sys.stderr)
|
|
|
|
def _set_status(self, text, tone=None, detail=None):
|
|
style = self.status.get_style_context()
|
|
|
|
for name in ("good", "bad", "waiting"):
|
|
style.remove_class(name)
|
|
|
|
if tone:
|
|
style.add_class(tone)
|
|
|
|
self.status.set_text(text or "")
|
|
self.status.set_visible(bool(text))
|
|
|
|
self.detail.set_text(detail or "")
|
|
self.detail.set_visible(bool(detail))
|
|
|
|
def _refresh_button(self):
|
|
ready = (
|
|
self.request_id is None
|
|
and self.broker_reachable
|
|
and contract.clean_child(self.entry.get_text()) is not None
|
|
and contract.availability(
|
|
self.mode, self.coordinator_online, self.broker_reachable,
|
|
assume_default=self.settled,
|
|
)[0]
|
|
)
|
|
self.primary.set_sensitive(bool(ready))
|
|
|
|
def _unavailable(self, message):
|
|
self.settled = True
|
|
self.entry.set_sensitive(False)
|
|
self.primary.hide()
|
|
self.hint.hide()
|
|
self.entry.hide()
|
|
self.close_button.set_label("Close")
|
|
self._set_status(message, tone="bad")
|
|
|
|
# -- events --------------------------------------------------------
|
|
|
|
def _event(self, kind, data):
|
|
if kind == "broker":
|
|
self.broker_reachable = data.get("reachable")
|
|
|
|
if not self.broker_reachable:
|
|
# Why it is not there decides who the teacher should
|
|
# fetch, so the reason the broker thread already knows is
|
|
# carried through to the card rather than flattened.
|
|
self._unavailable(contract.broker_message(data.get("why")))
|
|
else:
|
|
self._after(RETAINED_GRACE, self._retained_deadline)
|
|
|
|
elif kind == "mode":
|
|
self.mode = data.get("mode")
|
|
self._settle()
|
|
|
|
elif kind == "coordinator":
|
|
self.coordinator_online = bool(data.get("online"))
|
|
self._settle()
|
|
|
|
elif kind == "status":
|
|
self._status_arrived(data["update"])
|
|
|
|
elif kind == "published":
|
|
self.sent_at = time.monotonic()
|
|
self._after(FIRST_STATUS_TIMEOUT, self._first_status_deadline)
|
|
|
|
elif kind == "send-failed":
|
|
self._set_status("The call was not sent", tone="bad",
|
|
detail="Press Call parent to try again.")
|
|
self.request_id = None
|
|
self._refresh_button()
|
|
|
|
return False
|
|
|
|
def _settle(self, final=False):
|
|
"""Decide what to offer, once the retained topics have spoken.
|
|
|
|
A negative is only ever reached with final=True. The mode and the
|
|
coordinator's availability are two separate retained messages and
|
|
they arrive in whichever order the broker sends them — deciding on
|
|
the first one told a teacher the sanctuary was down while the
|
|
message saying otherwise was still in flight. Measured, in the
|
|
lab, on a coordinator that was demonstrably up.
|
|
"""
|
|
if self.request_id is not None or self.settled:
|
|
return
|
|
|
|
can, why = contract.availability(
|
|
self.mode, self.coordinator_online, self.broker_reachable,
|
|
assume_default=final,
|
|
)
|
|
|
|
if can:
|
|
self.entry.set_sensitive(True)
|
|
self.entry.grab_focus()
|
|
note = ("A volunteer will approve it first."
|
|
if self.mode == contract.MODE_APPROVAL else None)
|
|
self._set_status("", tone=None, detail=note)
|
|
self.settled = True
|
|
self._refresh_button()
|
|
|
|
if self.autosend:
|
|
self.autosend = False
|
|
GLib.timeout_add(300, lambda: (self._send(), False)[1])
|
|
elif final and why:
|
|
self._unavailable(why)
|
|
|
|
def _status_arrived(self, update):
|
|
self._set_status(
|
|
update["message"],
|
|
tone=("good" if update["good"]
|
|
else "bad" if update["terminal"]
|
|
else "waiting"),
|
|
detail=update.get("detail"),
|
|
)
|
|
|
|
if not update["terminal"]:
|
|
return
|
|
|
|
# Terminal: stop listening, as the coordinator's contract asks.
|
|
self.broker.request_id = None
|
|
|
|
if update["good"]:
|
|
self.close_button.hide()
|
|
self._after(CLOSE_AFTER_SUCCESS, self._quit)
|
|
else:
|
|
self.request_id = None
|
|
self.entry.set_sensitive(True)
|
|
self.entry.show()
|
|
self.hint.hide()
|
|
self.primary.set_label("Try again")
|
|
self.primary.show()
|
|
self._refresh_button()
|
|
|
|
# -- sending -------------------------------------------------------
|
|
|
|
def _send(self):
|
|
if self.request_id is not None:
|
|
return
|
|
|
|
child = contract.clean_child(self.entry.get_text())
|
|
|
|
if child is None:
|
|
self._set_status("Enter the child's name", tone="bad")
|
|
return
|
|
|
|
# The teacher is pressing the button, so the retained topics have
|
|
# long since had their chance.
|
|
can, why = contract.availability(
|
|
self.mode, self.coordinator_online, self.broker_reachable,
|
|
assume_default=True,
|
|
)
|
|
|
|
if not can:
|
|
self._unavailable(why or contract.WORDING[contract.UNAVAILABLE])
|
|
return
|
|
|
|
self.request_id = contract.new_request_id(self.room)
|
|
self.entry.set_sensitive(False)
|
|
self.primary.set_sensitive(False)
|
|
self.primary.hide()
|
|
self.hint.set_text(f"Calling a parent for {child}")
|
|
self.hint.show()
|
|
self._set_status("Sending", tone="waiting")
|
|
|
|
self.broker.send(self.request_id, self.room, child)
|
|
self._after(OVERALL_TIMEOUT, self._overall_deadline)
|
|
|
|
# -- deadlines -----------------------------------------------------
|
|
|
|
def _after(self, seconds, callback):
|
|
self._timers.append(GLib.timeout_add(int(seconds * 1000), callback))
|
|
|
|
def _connect_deadline(self):
|
|
if self.broker_reachable is None:
|
|
self._unavailable("Cannot reach the church network")
|
|
return False
|
|
|
|
def _retained_deadline(self):
|
|
# Retained topics arrive at once or not at all. Now that both have
|
|
# had their chance, a negative is safe to show, and a mode nobody
|
|
# has ever set is the coordinator's default rather than a room
|
|
# that was never configured.
|
|
self._settle(final=True)
|
|
|
|
if not self.settled:
|
|
# Only reachable if nothing at all came back from the
|
|
# sanctuary end, which the wording should say rather than
|
|
# blaming this room's setup.
|
|
self._unavailable("No answer from the sanctuary")
|
|
|
|
return False
|
|
|
|
def _first_status_deadline(self):
|
|
if self.request_id is not None and self.status.get_text() == "Sending":
|
|
# Silence is not a refusal, and is not reported as one.
|
|
self._set_status("No answer from the sanctuary", tone="bad",
|
|
detail="The call was not confirmed. "
|
|
"Press Try again, or ask for help.")
|
|
self.request_id = None
|
|
self.entry.set_sensitive(True)
|
|
self.primary.set_label("Try again")
|
|
self.primary.show()
|
|
self._refresh_button()
|
|
return False
|
|
|
|
def _overall_deadline(self):
|
|
if self.request_id is not None:
|
|
self._set_status("No answer from the sanctuary", tone="bad",
|
|
detail="The call was not confirmed.")
|
|
self.request_id = None
|
|
self.primary.set_label("Try again")
|
|
self.primary.show()
|
|
self._refresh_button()
|
|
return False
|
|
|
|
# -- leaving -------------------------------------------------------
|
|
|
|
def _key(self, _widget, event):
|
|
"""Escape leaves. Nothing else does.
|
|
|
|
Deliberately narrow: an earlier version compared against a Gdk
|
|
that had not been version-pinned, and in the lab an ordinary
|
|
letter closed the card.
|
|
"""
|
|
if event.keyval == Gdk.KEY_Escape and not event.state & (
|
|
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD1_MASK
|
|
):
|
|
self._quit()
|
|
return True
|
|
|
|
return False
|
|
|
|
def _quit(self, *_):
|
|
for timer in self._timers:
|
|
GLib.source_remove(timer)
|
|
self._timers = []
|
|
|
|
self.broker.stop()
|
|
Gtk.main_quit()
|
|
return False
|
|
|
|
|
|
def main():
|
|
GLib.set_prgname(APP_ID)
|
|
GLib.set_application_name("Parent Call")
|
|
|
|
# A device that does not offer Parent Call does not offer it. The
|
|
# panel has no button, so nothing should reach here; saying it out
|
|
# loud is for the technician who ran the command by hand and wants to
|
|
# know why. Defaults to true, so every existing room is unaffected.
|
|
if not feature(read_device_config(), "PARENT_CALL_ENABLED"):
|
|
print("classroom-parent-call: PARENT_CALL_ENABLED is false on this "
|
|
"device; not starting", flush=True)
|
|
return 0
|
|
|
|
# --child fills the name in, and --send presses the button once the
|
|
# sanctuary has answered for whether it may be pressed. Only the lab
|
|
# uses them: there is no teacher-facing path to either, and neither
|
|
# can send a call the coordinator would not have accepted anyway.
|
|
child = None
|
|
autosend = "--send" in sys.argv
|
|
|
|
if "--child" in sys.argv:
|
|
index = sys.argv.index("--child") + 1
|
|
if index < len(sys.argv):
|
|
child = sys.argv[index]
|
|
|
|
window = ParentCall()
|
|
|
|
if child:
|
|
window.entry.set_text(child)
|
|
|
|
if autosend:
|
|
window.autosend = True
|
|
|
|
window.show()
|
|
|
|
Gtk.main()
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|