Kamera und Chat -- die zwei fehlenden Host-Steuerungen
Filipes Notiz nennt acht: "Host-Steuerung fuer Kamera, Mikrofon,
Video, Gaeste, Lautstaerke, Chat, Layout und Start/Ende."
Nachgezaehlt war sechsmal etwas da und zweimal nichts.
KAMERA
Es gab keinen Weg, das eigene Bild abzuschalten. Wer kurz aufstehen,
trinken oder etwas holen wollte, musste die Sendung verlassen oder
sich dabei filmen lassen.
Jetzt liegt eine SENDERLEISTE ueber dem Bild -- Kamera, Mikro und ein
Pegel. Sie gehoert jedem, der sendet, Host wie Gast: Ein Gast, der
sein eigenes Bild nicht abschalten kann, muesste den Host darum
bitten, und das ist keine Bedienung, sondern eine Bitte.
DAS BILD WIRD AM GERAET ABGESCHALTET (`track.enabled = false`), nicht
am Server: Die Verbindung bleibt stehen, der Ton laeuft weiter, und
beim Wiedereinschalten ist das Bild sofort da. Der Server erfaehrt es
nur, damit bei den ANDEREN "Kamera aus" im Fenster steht. Ohne diese
Beschriftung sind ein abgeschaltetes und ein kaputtes Bild dasselbe
schwarze Rechteck -- und dann fragt jemand im Chat, ob die Technik
hakt.
Erst das Geraet, dann die Ansage. Andersherum stuende bei allen
"Kamera aus", waehrend noch ein Bild fliesst; man glaubte sich
unsichtbar. Geht die Ansage nicht durch, wird das Geraet
zurueckgesetzt -- ein Knopf, der halb wirkt, ist schlimmer als einer,
der gar nicht wirkt.
Das Mikro laeuft denselben Weg. Erst wollte ich es rein oertlich
lassen; das waere dieselbe stille Falle gewesen: Wer sich selbst
stummschaltet und trotzdem redet, saehe bei allen anderen ein ganz
normales Fenster.
CHAT
Es gab Moderation -- Beitraege wegnehmen -- aber keine Steuerung des
Chats selbst. Einen Beitrag zu loeschen, nachdem er stand, ist etwas
anderes, als ihn gar nicht erst zuzulassen.
Drei Stufen: OFFEN, TEAM (wer moderiert, darf -- wer aufraeumen soll,
muss dabei reden koennen) und ZU (nur die zwei, die fuehren). Zwei
Stufen waeren zu wenig: "zu" ist in einer Sendung fast immer zu viel,
dann sitzen alle vor einem stummen Fenster. Die mittlere ist die, die
man wirklich braucht.
Die Schalter stehen im Kopf der Chatschiene, nicht im Regiepult: Man
moderiert, wo man liest. Ein Umweg ueber ein Register waere in dem
Moment, in dem es laut wird, genau ein Umweg zu viel.
EIN GESPERRTES FELD SAGT, WARUM. "Gerade schreibt nur das Team" statt
eines Feldes, das sich nicht beschreiben laesst und schweigt --
sonst schreibt jemand in den Hauschat, dass die Reaction hakt. Und
die Stufe gilt AM SERVER: Ein ausgegrautes Feld haelt niemanden auf,
der die Schnittstelle kennt. Beide Antworten kommen aus derselben
Funktion; zwei Rechnungen waeren zwei Gelegenheiten, dass ein Feld da
ist und mit 403 antwortet.
EIN FUND NEBENBEI: "MEIN MIKRO" WAR EIN PLACEBO
Gemessen: `staende.mikro` wird nirgends gelesen. Der Schieber liess
sich bewegen, die Zahl daneben aenderte sich -- und es passierte
nichts. Das ist schlimmer als ein fehlender Regler: Man glaubt, man
haette leiser gestellt.
Technisch ist das auch richtig. Die eigene Lautstaerke laesst sich
nicht am Regler aendern; man muesste den Ton umrechnen und die Spur
in jeder Verbindung austauschen. Was man beim eigenen Mikro braucht,
ist AN oder AUS -- und ein Pegel, der zeigt, dass es ankommt. Genau
das steht jetzt dort, als vierte Spalte im Pult, mit demselben
Zustand wie die Senderleiste. Die drei anderen Regler bleiben Regler:
Sie steuern, was ICH hoere, und das geht am Empfaenger.
UND EINER IN MEINER EIGENEN ARBEIT
`kasten.append(el("div","pegel")).append(el("i"))` -- `Node.append()`
gibt `undefined` zurueck, nicht das angehaengte Element. Ein
TypeError beim Aufbau des Pults, den `node --check` nicht sieht.
Beim Verkuerzen nicht nachgesehen, was die Methode zurueckgibt.
Dazu: Die Pegel-Takte liefen in `pultAufbauen()`. Das Pult hat nur,
wer die Sendung fuehrt -- ein Gast haette seinen Pegel nie gesehen,
und genau er braucht ihn am dringendsten.
GEMESSEN
mess-reaktion Der Host schaltet ab, und bei der Zuschauerin steht
"Kamera aus" bei DogFather, Bild verdeckt.
Stufe "Team": Feld gesperrt mit Grund, und der
Server lehnt denselben Versuch mit 403 ab.
pruef-reaktion 154 Punkte, 0 Fehler (vorher 132), neuer Abschnitt
13 mit 22 Punkten und Gegenprobe (es geht auch
wieder auf -- eine Sperre, die man nicht loesen
kann, ist keine Stufe, sondern ein Ende)
dazu gruen handy 180, css-klassen 33, struktur 35,
tippziele 11, aufbewahrung 45, meldungen 8
Der neue Abschnitt baut sich seine Buehne selbst. Abschnitt 9 beendet
die Sendung; sich auf den Stand eines frueheren Abschnitts zu
verlassen ist die Kopplung, die spaeter jemand aus Versehen
zerreisst.
SCHEMA: drei Spalten (reaktion_dabei.kamera_aus, .mikro_aus,
reaktion.chat_modus), alle per ALTER TABLE. Auf einer Kopie der
echten Datenbank durchgespielt: 20 Personen, keine Tabelle verliert
eine Spalte.
This commit is contained in:
+156
-3
@@ -880,10 +880,163 @@ melde("=== 12. Die Regie ===");
|
||||
}
|
||||
|
||||
/* =======================================================================
|
||||
13. KEIN WEG HEISST ZWEIMAL GLEICH
|
||||
13. KAMERA UND CHAT — die zwei fehlenden Host-Steuerungen
|
||||
|
||||
Filipes Notiz nennt acht: Kamera, Mikrofon, Video, Gaeste,
|
||||
Lautstaerke, Chat, Layout, Start/Ende. Nachgezaehlt war sechsmal
|
||||
etwas da und zweimal nichts.
|
||||
======================================================================= */
|
||||
melde("");
|
||||
melde("=== 13. Keine doppelten Wege ===");
|
||||
melde("=== 13. Kamera und Chat ===");
|
||||
{
|
||||
/* ABSCHNITT 9 HAT DIE SENDUNG BEENDET -- also wird hier neu
|
||||
aufgemacht. Sich auf den Stand eines frueheren Abschnitts zu
|
||||
verlassen ist die Kopplung, die spaeter jemand aus Versehen
|
||||
zerreisst; dann faellt ein Abschnitt um, an dem nichts falsch
|
||||
ist. */
|
||||
await roh(CREW, "/workspace/api/reaktion", {
|
||||
method: "PUT", keks: k.admin,
|
||||
rumpf: { titel: "Kamera und Chat", video: "dQw4w9WgXcQ" },
|
||||
});
|
||||
await roh(CREW, "/workspace/api/reaktion/stand", {
|
||||
method: "POST", keks: k.admin, rumpf: { stand: "live" },
|
||||
});
|
||||
for (const rolle of ["admin", "hand", "linke", "modi", "gast", "gast2"]) {
|
||||
await roh(CREW, "/workspace/api/reaktion/dabei", { method: "POST", keks: k[rolle] });
|
||||
}
|
||||
await roh(CREW, "/workspace/api/reaktion/gast", {
|
||||
method: "POST", keks: k.admin, rumpf: { person_id: IDS.gast2 },
|
||||
});
|
||||
|
||||
const stand0 = await roh(CREW, "/workspace/api/reaktion", { keks: k.admin });
|
||||
ok(stand0.j?.stand === "live" && stand0.j?.gaeste?.length === 1,
|
||||
`die Buehne steht (${stand0.j?.stand}, ${stand0.j?.gaeste?.length} Gast)`);
|
||||
|
||||
/* ---- Kamera ---- */
|
||||
const fremd = await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.gast, rumpf: { kamera_aus: true },
|
||||
});
|
||||
ok(fremd.code === 403 && fremd.j?.fehler === "sendest_nicht",
|
||||
`wer nicht sendet, schaltet nichts (${fremd.code}/${fremd.j?.fehler})`);
|
||||
|
||||
const aus = await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.admin, rumpf: { kamera_aus: true },
|
||||
});
|
||||
ok(aus.code === 200 && aus.j?.ich?.kamera_aus === true,
|
||||
`der Host schaltet sein Bild ab (${aus.code})`);
|
||||
ok(aus.j?.host?.kamera_aus === true,
|
||||
"und es steht an der Sendung, damit es ALLE sehen");
|
||||
|
||||
/* TEILWEISE AENDERN DARF DEN ANDEREN WERT NICHT ANFASSEN. Sonst
|
||||
muesste jede Seite immer beide Werte mitschicken -- und wer das
|
||||
vergisst, schaltet dem anderen versehentlich das Bild wieder an. */
|
||||
const nurMikro = await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.admin, rumpf: { mikro_aus: true },
|
||||
});
|
||||
ok(nurMikro.j?.ich?.mikro_aus === true && nurMikro.j?.ich?.kamera_aus === true,
|
||||
"nur das Mikro zu schalten laesst die Kamera in Ruhe");
|
||||
|
||||
const leer = await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.admin, rumpf: {},
|
||||
});
|
||||
ok(leer.code === 400 && leer.j?.fehler === "nichts_zu_tun",
|
||||
`ein Aufruf ohne Inhalt sagt das auch (${leer.code})`);
|
||||
|
||||
/* Ein Gast darf es fuer sich -- sonst muesste er den Host bitten. */
|
||||
const gastAus = await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.gast2, rumpf: { kamera_aus: true },
|
||||
});
|
||||
ok(gastAus.code === 200,
|
||||
`ein Gast schaltet sein eigenes Bild ab (${gastAus.code})`);
|
||||
const beimHost = await roh(CREW, "/workspace/api/reaktion", { keks: k.admin });
|
||||
ok(beimHost.j?.gaeste?.some((g) => g.id === IDS.gast2 && g.kamera_aus === true),
|
||||
"und der Host sieht es an der Gastkarte");
|
||||
|
||||
/* Zurueck, damit der Rest der Pruefung von einem sauberen Stand
|
||||
aus weiterlaeuft. */
|
||||
await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.admin, rumpf: { kamera_aus: false, mikro_aus: false },
|
||||
});
|
||||
await roh(CREW, "/workspace/api/reaktion/senden", {
|
||||
method: "POST", keks: k.gast2, rumpf: { kamera_aus: false },
|
||||
});
|
||||
|
||||
/* ---- Chat ---- */
|
||||
for (const rolle of ["linke", "modi", "gast"]) {
|
||||
const a = await roh(CREW, "/workspace/api/reaktion/chatmodus", {
|
||||
method: "POST", keks: k[rolle], rumpf: { modus: "zu" },
|
||||
});
|
||||
ok(a.code === 403, `${rolle}: stellt den Chat nicht um (${a.code})`);
|
||||
}
|
||||
const unsinn = await roh(CREW, "/workspace/api/reaktion/chatmodus", {
|
||||
method: "POST", keks: k.admin, rumpf: { modus: "halboffen" },
|
||||
});
|
||||
ok(unsinn.code === 400 && unsinn.j?.fehler === "chatmodus_unbekannt",
|
||||
`eine erfundene Stufe wird abgelehnt (${unsinn.code})`);
|
||||
|
||||
const offen = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.gast, rumpf: { text: "offen geht" },
|
||||
});
|
||||
ok(offen.code === 201, `bei „offen" schreibt die Community (${offen.code})`);
|
||||
|
||||
const team = await roh(CREW, "/workspace/api/reaktion/chatmodus", {
|
||||
method: "POST", keks: k.hand, rumpf: { modus: "team" },
|
||||
});
|
||||
ok(team.code === 200 && team.j?.chat_modus === "team",
|
||||
`die rechte Hand stellt auf „Team" (${team.j?.chat_modus})`);
|
||||
|
||||
const gastTeam = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.gast, rumpf: { text: "und jetzt?" },
|
||||
});
|
||||
ok(gastTeam.code === 403 && gastTeam.j?.fehler === "chat_nur_team",
|
||||
`dann schweigt die Community (${gastTeam.code}/${gastTeam.j?.fehler})`);
|
||||
const modiTeam = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.modi, rumpf: { text: "wir ordnen kurz" },
|
||||
});
|
||||
ok(modiTeam.code === 201, `ein Modi schon -- er soll ja ordnen (${modiTeam.code})`);
|
||||
|
||||
/* DIE OBERFLAECHE MUSS DIESELBE ANTWORT BEKOMMEN wie der Server.
|
||||
Sonst steht ein Feld da, das sich beschreiben laesst und beim
|
||||
Absenden 403 sagt -- eine Falle, keine Bedienung. */
|
||||
const sichtGast = await roh(CREW, "/workspace/api/reaktion", { keks: k.gast });
|
||||
ok(sichtGast.j?.ich?.darf_schreiben === false,
|
||||
"und die Oberflaeche erfaehrt es, bevor jemand tippt");
|
||||
const sichtModi = await roh(CREW, "/workspace/api/reaktion", { keks: k.modi });
|
||||
ok(sichtModi.j?.ich?.darf_schreiben === true,
|
||||
"der Modi erfaehrt das Gegenteil");
|
||||
|
||||
const zu = await roh(CREW, "/workspace/api/reaktion/chatmodus", {
|
||||
method: "POST", keks: k.admin, rumpf: { modus: "zu" },
|
||||
});
|
||||
ok(zu.j?.chat_modus === "zu", "die Stufe zu geht auch");
|
||||
const modiZu = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.modi, rumpf: { text: "auch ich?" },
|
||||
});
|
||||
ok(modiZu.code === 403 && modiZu.j?.fehler === "chat_zu",
|
||||
`dann schweigt auch der Modi (${modiZu.code}/${modiZu.j?.fehler})`);
|
||||
const hostZu = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.admin, rumpf: { text: "ich sage noch etwas" },
|
||||
});
|
||||
ok(hostZu.code === 201,
|
||||
`die zwei, die fuehren, koennen weiter reden (${hostZu.code})`);
|
||||
|
||||
/* GEGENPROBE: Es geht auch wieder auf. Eine Sperre, die man nicht
|
||||
loesen kann, ist keine Stufe, sondern ein Ende. */
|
||||
await roh(CREW, "/workspace/api/reaktion/chatmodus", {
|
||||
method: "POST", keks: k.admin, rumpf: { modus: "offen" },
|
||||
});
|
||||
const wiederOffen = await roh(CREW, "/workspace/api/reaktion/chat", {
|
||||
method: "POST", keks: k.gast, rumpf: { text: "wieder da" },
|
||||
});
|
||||
ok(wiederOffen.code === 201,
|
||||
`Gegenprobe: zurueck auf „offen", und die Community schreibt wieder (${wiederOffen.code})`);
|
||||
}
|
||||
|
||||
/* =======================================================================
|
||||
14. KEIN WEG HEISST ZWEIMAL GLEICH
|
||||
======================================================================= */
|
||||
melde("");
|
||||
melde("=== 14. Keine doppelten Wege ===");
|
||||
{
|
||||
/* Beim Notizblock hat genau das eine Stunde gekostet:
|
||||
`DELETE /workspace/api/notizen/:id` gab es schon woanders, und
|
||||
@@ -907,7 +1060,7 @@ melde("=== 13. Keine doppelten Wege ===");
|
||||
ok(doppelt.length === 0,
|
||||
doppelt.length ? `DOPPELT: ${[...new Set(doppelt)].join(", ")}` : "kein Weg kommt zweimal vor");
|
||||
const reaktionswege = wege.filter((x) => x.includes("/api/reaktion")).length;
|
||||
ok(reaktionswege >= 15, `die Reaction bringt ${reaktionswege} eigene Wege mit`);
|
||||
ok(reaktionswege >= 17, `die Reaction bringt ${reaktionswege} eigene Wege mit`);
|
||||
}
|
||||
|
||||
melde("");
|
||||
|
||||
Reference in New Issue
Block a user