tango.git - Ulrich Hilger Code Repository

Funktion 'naechster Titel' beim Abspielen von Abspiellisten eingebaut

undisclosed

2023-01-29 183d3e0c669aa8882c994c8ef756e1ac1d61fd7d

commit \| author \| age
b56bb3	1	/*
94b1c2	2	Tango - Personal Media Center
b56bb3	3	Copyright (C) 2021 Ulrich Hilger
U	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU Affero General Public License as
	7	published by the Free Software Foundation, either version 3 of the
	8	License, or (at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU Affero General Public License for more details.
	14
	15	You should have received a copy of the GNU Affero General Public License
	16	along with this program. If not, see <https://www.gnu.org/licenses/>.
	17	*/
94b1c2	18	package de.uhilger.tango.api;
b56bb3	19
1c5fa4	20	import com.google.gson.Gson;
b56bb3	21	import com.sun.net.httpserver.HttpExchange;
94b1c2	22	import de.uhilger.tango.Server;
U	23	import de.uhilger.tango.entity.Abspielvorgang;
	24	import de.uhilger.tango.entity.Abspieler;
	25	import de.uhilger.tango.entity.Abspielliste;
	26	import de.uhilger.tango.entity.Entity;
	27	import de.uhilger.tango.entity.Livestream;
	28	import de.uhilger.tango.entity.Titel;
	29	import de.uhilger.tango.store.FileStorage;
	30	import de.uhilger.tango.store.Storage;
005d7a	31	import java.io.IOException;
U	32	import java.net.HttpURLConnection;
	33	import java.net.URL;
b56bb3	34	import java.util.HashMap;
U	35	import java.util.Map;
0e9cd3	36	import java.util.logging.Level;
b56bb3	37	import java.util.logging.Logger;
U	38
	39	/**
0e9cd3	40	* Die MediaSteuerung verarbeitet HTTP-Signale zur Steuerung von Media-Operationen wie z.B. dem
U	41	* Spielen einer Abspielliste oder dem Starten oder Stoppen eines Videos auf einem entfernten
	42	* Abspielgeraet.
	43	*
	44	* HTTP GET /mz/api/strg/abspieler/play/liste/[name]
183d3e	45	* HTTP GET /mz/api/strg/abspieler/next
0e9cd3	46	* HTTP GET /mz/api/strg/abspieler/ende
U	47	*
d027b5	48	* HTTP POST /mz/api/strg/abspieler/play/titel mit dem Titel im Body
U	49	* HTTP POST /mz/api/strg/abspieler/play/stream mit dem Livestream im Body (nur Name gefuellt)
c6fdc4	50	*
183d3e	51	* DEPRECATED: HTTP POST /mz/api/strg/abspieler/weiter/titel mit dem Titel im Body
0e9cd3	52	*
589850	53	* HTTP GET /mz/api/strg/abspieler/pause
U	54	* HTTP GET /mz/api/strg/abspieler/stop
792b21	55	* HTTP GET /mz/api/strg/abspieler/seek/[sekunden]
b56bb3	56	*
0e9cd3	57	* Faustregel: Anzahl Elemente eines URL plus 1 ist die Anzahl der Elemente des
U	58	* Ergebnisses von String.split.
	59	*
1ff360	60	* Mit der Funktion ende liefert die MediaSteuerung die Moeglichkeit, Titel aus
U	61	* einer Abspielliste gesteuert von Tango abzuspielen. Die Nutzung der Funktion wird
	62	* ausgeloest vom Aufruf an abspieler/play/liste/[name]. Tango erwartet dann von einem
	63	* Abspieler die Rueckmeldung, dass dieser den zuletzt von Tango an den
	64	* Abspieler zum Abspielen uebermittelten Titel zuende abgespielt hat. Tango
	65	* uebergibt dem Abspieler dann den naechsten Titel, bis die Abspielliste zuende ist.
	66	*
	67	* Diese Form unterscheidet sich vom Abspielen einer Abspielliste als einzelner
	68	* Stream, wie es vom StreamHandler realisiert wird.
0e9cd3	69	*
b56bb3	70	* @author Ulrich Hilger
U	71	* @version 1, 9.4.2021
	72	*/
	73	public class MediaSteuerung extends AbstractHandler {
	74
	75	private static final Logger logger = Logger.getLogger(MediaSteuerung.class.getName());
0e9cd3	76
f9f819	77	public static final String PL_CMD_PLAY = "play";
792b21	78	public static final String PL_CMD_SEEK = "seek";
0e9cd3	79	public static final String PL_DEFAULT_PARAMS = "?titel=";
005d7a	80	public static final String PL_PARAM_RUECK = "&r=";
960359	81	public static final String PL_API_STRG = "api/strg/";
0e9cd3	82	public static final String PL_CMD_ENDE = "ende";
589850	83	public static final String PL_CMD_STOP = "stop";
392dc9	84	public static final String PL_CMD_VOLDN = "voldn";
U	85	public static final String PL_CMD_VOLUP = "volup";
589850	86	public static final String PL_CMD_PAUSE = "pause";
c6fdc4	87	public static final String PL_CMD_PLAYON = "weiter";
183d3e	88	public static final String PL_CMD_NEXT = "next";
f9f819	89	public static final String PL_CMD_CALYPSO_STOP = "stop";
392dc9	90	public static final String PL_CMD_CALYPSO_VOL_INC = "vol-inc";
U	91	public static final String PL_CMD_CALYPSO_VOL_DEC = "vol-dec";
f9f819	92	public static final String PL_CMD_CALYPSO_PAUSE = "pause";
U	93	public static final String PL_CMD_CALYPSO_PLAYON = "playon";
005d7a	94	public static final String DEFAULT_HOST = "http://localhost:9090";
0e9cd3	95
ad3e2d	96	public static final String RB_HOST = "host";
U	97	public static final String RB_PLAYERPARAMS = "playerparams";
	98
0e9cd3	99	private final Map spielt = new HashMap();
f70acb	100
U	101	private String conf;
	102
	103	public MediaSteuerung(String conf) {
	104	this.conf = conf;
	105	}
b56bb3	106
U	107	@Override
	108	protected String get(HttpExchange e) {
0e9cd3	109	String response;
b56bb3	110	String path = e.getRequestURI().toString();
0e9cd3	111	String[] elems = path.split(Server.SLASH);
f70acb	112	FileStorage fs = new FileStorage(conf);
589850	113	logger.fine(path);
0e9cd3	114
U	115	// Faustregel: Anzahl Elemente eines URL plus 1 ist die Anzahl der Elemente des
	116	// Ergebnisses von String.split.
	117	switch (elems.length) {
	118	case 6:
	119	if (elems[5].equalsIgnoreCase(PL_CMD_ENDE)) {
	120	response = naechsterTitel(fs, elems[4]);
589850	121	} else if(elems[5].equalsIgnoreCase(PL_CMD_STOP)) {
d12f6e	122	spielt.remove(elems[4]);
4bbb9f	123	response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_STOP);
392dc9	124	} else if(elems[5].equalsIgnoreCase(PL_CMD_VOLDN)) {
U	125	response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_VOL_DEC);
	126	} else if(elems[5].equalsIgnoreCase(PL_CMD_VOLUP)) {
	127	response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_VOL_INC);
589850	128	} else if(elems[5].equalsIgnoreCase(PL_CMD_PAUSE)) {
4bbb9f	129	response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_PAUSE);
c6fdc4	130	//} else if(elems[5].equalsIgnoreCase(PL_CMD_PLAYON)) {
U	131	// response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_PLAYON);
183d3e	132	} else if(elems[5].equalsIgnoreCase(PL_CMD_NEXT)) {
U	133	response = kommandoSenden(fs, elems[4], PL_CMD_CALYPSO_STOP);
	134	//response = naechsterTitel(fs, elems[4]);
0e9cd3	135	} else {
U	136	response = meldung("Ungueltiges Kommando: " + elems[5], AbstractHandler.RTC_NOT_FOUND);
	137	}
	138	break;
792b21	139	case 7:
U	140	if (elems[5].equalsIgnoreCase(PL_CMD_SEEK)) {
	141	// /calypso/seek?pos=[sekunden]
	142	response = kommandoSenden(fs, elems[4], "seek?pos=" + elems[6]);
	143	} else {
	144	response = meldung("Ungueltiges Kommando: " + elems[5], AbstractHandler.RTC_NOT_FOUND);
	145	}
	146	break;
b56bb3	147	case 8:
1c5fa4	148	response = ersterTitel(fs, elems[4], elems[7]);
0e9cd3	149	break;
U	150	default:
	151	response = "Ungueltiger URL";
b56bb3	152	break;
U	153	}
	154	return response;
589850	155	}
1c5fa4	156
U	157	@Override
	158	protected String post(HttpExchange e) {
	159	String response;
c6fdc4	160	String abspielerKmd = PL_CMD_PLAY;
U	161	String path = e.getRequestURI().toString();
	162	String[] elems = path.split(Server.SLASH);
	163	logger.info(elems[5]);
183d3e	164	// PLAYON ist deprecated
U	165	//if(elems[5].equalsIgnoreCase(PL_CMD_PLAYON)) {
	166	// abspielerKmd = PL_CMD_CALYPSO_PLAYON;
	167	//} else if(elems[5].equalsIgnoreCase(PL_CMD_PLAY)){
	168	// abspielerKmd = PL_CMD_PLAY;
	169	//}
	170	if(elems[5].equalsIgnoreCase(PL_CMD_PLAY)){
c6fdc4	171	abspielerKmd = PL_CMD_PLAY;
U	172	}
1c5fa4	173	try {
c6fdc4	174	return urlAbspielen(e, abspielerKmd);
1c5fa4	175	} catch (IOException ex) {
U	176	logger.log(Level.SEVERE, null, ex);
	177	return meldung(ex.getLocalizedMessage(), 404);
	178	}
	179	}
589850	180
1c5fa4	181	// titel.katalogUrl + titel.pfad + titel.name
c6fdc4	182	private String urlAbspielen(HttpExchange e, String abspielerKmd) throws IOException {
1c5fa4	183	String path = e.getRequestURI().toString();
U	184	String[] elems = path.split(Server.SLASH);
f70acb	185	FileStorage fs = new FileStorage(conf);
c6fdc4	186	if(elems[6].equalsIgnoreCase("titel")) {
d027b5	187	String titelJson = bodyLesen(e);
U	188	Gson gson = new Gson();
	189	Object o = gson.fromJson(titelJson, fs.typeFromName(Titel.class.getSimpleName()).getType());
	190	if(o instanceof Titel) {
	191	Titel titel = (Titel) o;
	192	String titelUrl = titel.getKatalogUrl() + titel.getPfad() + titel.getName();
	193	Entity entity = fs.read(FileStorage.ST_ABSPIELER, elems[4]);
	194	if (entity instanceof Abspieler) {
	195	Abspieler abspieler = (Abspieler) entity;
ad3e2d	196	String server = getEinstellung(fs, getResString(RB_HOST), DEFAULT_HOST);
c6fdc4	197	String signal = abspielKommando(fs, abspieler, server, titelUrl, abspielerKmd).toString();
d027b5	198	abspielerKommandoSenden(signal);
U	199	return signal + "gesendet.";
	200	} else {
	201	return meldung("Ungueltiger Abspieler.", 404);
	202	}
1c5fa4	203	} else {
d027b5	204	return meldung("Ungueltiger Titel.", 404);
1c5fa4	205	}
c6fdc4	206	} else if(elems[6].equalsIgnoreCase("stream")) {
d027b5	207	String streamJson = bodyLesen(e);
U	208	Gson gson = new Gson();
	209	Object o = gson.fromJson(streamJson, fs.typeFromName(Livestream.class.getSimpleName()).getType());
	210	if(o instanceof Livestream) {
	211	Entity entity = fs.read(FileStorage.ST_LIVESTREAM, ((Livestream) o).getName());
	212	if(entity instanceof Livestream) {
	213	Livestream stream = (Livestream) entity;
	214	entity = fs.read(FileStorage.ST_ABSPIELER, elems[4]);
	215	if (entity instanceof Abspieler) {
	216	Abspieler abspieler = (Abspieler) entity;
	217	String server = "";
c6fdc4	218	String signal = abspielKommando(fs, abspieler, server, stream.getUrl(), PL_CMD_PLAY).toString();
d027b5	219	abspielerKommandoSenden(signal);
U	220	return signal + "gesendet.";
	221	} else {
	222	return meldung("Ungueltiger Abspieler.", 404);
	223	}
	224	} else {
	225	return meldung("Ungueltiger Livestream.", 404);
	226	}
	227	} else {
	228	return meldung("Ungueltiger Livestream.", 404);
	229	}
1c5fa4	230	} else {
d027b5	231	return meldung("Ungueltiger URL.", 404);
658c14	232	}
U	233	}
	234
c6fdc4	235
589850	236	private String kommandoSenden(Storage s, String aName, String kommando) {
U	237	Entity entity = s.read(FileStorage.ST_ABSPIELER, aName);
	238	if (entity instanceof Abspieler) {
	239	Abspieler abspieler = (Abspieler) entity;
	240	StringBuilder kmd = new StringBuilder();
	241	kmd.append(abspieler.getUrl());
	242	kmd.append(kommando);
9e14ef	243	String signal = kmd.toString();
c6fdc4	244	//String server = getEinstellung(s, App.getRs(App.RB_HOST), DEFAULT_HOST);
U	245	//String signal = abspielKommando(s, abspieler, server, stream.getUrl(), PL_CMD_PLAY).toString();
9e14ef	246	abspielerKommandoSenden(signal);
U	247	return signal + " gesendet.";
589850	248	} else {
U	249	return meldung("Abspielliste nicht gefunden.", AbstractHandler.RTC_NOT_FOUND);
	250	}
b56bb3	251	}
c6fdc4	252
b56bb3	253
5f7e0b	254	private String ersterTitel(Storage s, String aName, String lName) {
U	255	String response;
	256	Entity entity = s.read(FileStorage.ST_ABSPIELLISTE, lName);
	257	if (entity instanceof Abspielliste) {
	258	Abspielliste liste = (Abspielliste) entity;
	259	response = listentitelSpielen(s, aName, liste, 0);
	260	} else {
	261	response = meldung("Abspielliste nicht gefunden.", AbstractHandler.RTC_NOT_FOUND);
	262	}
	263	return response;
0e9cd3	264	}
U	265
	266	private String naechsterTitel(Storage s, String abspielerName) {
	267	String response;
	268	Object o = spielt.get(abspielerName);
	269	if (o instanceof Abspielvorgang) {
	270	Abspielvorgang av = (Abspielvorgang) o;
	271	Entity entity = s.read(FileStorage.ST_ABSPIELLISTE, av.getListe());
	272	if (entity instanceof Abspielliste) {
b56bb3	273	Abspielliste liste = (Abspielliste) entity;
0e9cd3	274	int titelNr = av.getTitelNr();
U	275	if (liste.getTitel().size() > ++titelNr) {
005d7a	276	response = listentitelSpielen(s, abspielerName, liste, titelNr);
0e9cd3	277	} else {
U	278	response = "Liste " + liste.getName() + " ist zuende gespielt.";
589850	279	logger.info(response);
0e9cd3	280	}
U	281	} else {
	282	response = meldung("Abspielliste nicht gefunden.", AbstractHandler.RTC_NOT_FOUND);
b56bb3	283	}
0e9cd3	284	//response = listenTitelSpielen(e, elems[4]);
U	285	} else {
	286	response = meldung("Abspielvorgang fuer Abspieler " + abspielerName, AbstractHandler.RTC_NOT_FOUND);
b56bb3	287	}
U	288	return response;
	289	}
0e9cd3	290
005d7a	291	private String listentitelSpielen(Storage s, String aName, Abspielliste liste, int titelNr) {
0e9cd3	292	String response;
U	293	Entity entity = s.read(FileStorage.ST_ABSPIELER, aName);
	294	if (entity instanceof Abspieler) {
	295	Abspieler abspieler = (Abspieler) entity;
	296	String kommando = kommandoFuerTitel(s, liste, abspieler, titelNr);
	297	//String kommando = kmd.toString();
	298	logger.info(kommando);
5f7e0b	299	abspielerKommandoSenden(kommando);
0e9cd3	300	response = "Abspielen der Liste " + liste.getName() + " auf Abspieler " + aName + " gestartet.";
U	301	} else {
	302	response = meldung("Abspieler nicht gefunden.", AbstractHandler.RTC_NOT_FOUND);
	303	}
	304	return response;
	305	}
	306
	307	/**
	308	* Das Kommando zum Abspielen fuer den Titel einer Abspielliste und einen bestimmten Abspieler
	309	* ermitteln.
	310	*
	311	* @param s die Ablage, in der Abspieler und Abspiellisten zu finden sind
	312	* @param liste Name der Liste, die den gewuenschten Titel enthaelt
	313	* @param abspieler Name des Abspielers, der zum Abspielen dienen soll
	314	* @param titelNr Nummer des Titels in der Liste
	315	* @return das Kommando zum Abspielen (ein URL)
	316	*/
	317	private String kommandoFuerTitel(Storage s, Abspielliste liste, Abspieler abspieler, int titelNr) {
	318	// ersten Titel aus Liste holen
	319	Titel titel = liste.getTitel().get(titelNr);
	320
	321	// URL des Titels ermitteln
	322	String titelUrl = titel.getKatalogUrl() + titel.getPfad() + titel.getName();
	323	logger.log(Level.INFO, "abspielen von {0} auf {1}", new Object[]{titelUrl, abspieler.getUrl()});
	324
	325	// Titel als 'spielt' vermerken
	326	Abspielvorgang vorgang = new Abspielvorgang();
	327	vorgang.setAbspieler(abspieler.getName());
	328	vorgang.setListe(liste.getName());
	329	vorgang.setTitelNr(titelNr);
	330	spielt.put(abspieler.getName(), vorgang);
005d7a	331
ad3e2d	332	String server = getEinstellung(s, getResString(RB_HOST), DEFAULT_HOST);
0e9cd3	333
1c5fa4	334	/*
U	335
0e9cd3	336	// Kommando an den Abspieler zusammenbauen
U	337	StringBuilder kmd = new StringBuilder();
	338	kmd.append(abspieler.getUrl());
	339	kmd.append(PL_CMD_PLAY);
	340	// Parameter fuer den Abspieler holen
005d7a	341	kmd.append(getEinstellung(s, App.getRs(App.RB_PLAYERPARAMS), PL_DEFAULT_PARAMS));
U	342	kmd.append(server);
0e9cd3	343	kmd.append(titelUrl);
1c5fa4	344	*/
c6fdc4	345	StringBuilder kmd = abspielKommando(s, abspieler, server, titelUrl, PL_CMD_PLAY);
005d7a	346	kmd.append(PL_PARAM_RUECK);
U	347	kmd.append(server);
3a0556	348	if(!server.endsWith(Server.SLASH)) {
U	349	kmd.append(Server.SLASH);
	350	}
005d7a	351	kmd.append(PL_API_STRG);
U	352	kmd.append(abspieler.getName());
	353	kmd.append("/ende");
0e9cd3	354
U	355	return kmd.toString();
	356	}
1c5fa4	357
c6fdc4	358	private StringBuilder abspielKommando(Storage s, Abspieler abspieler, String server, String titelUrl, String abspielKmd) {
1c5fa4	359
U	360	// Kommando an den Abspieler zusammenbauen
	361	StringBuilder kmd = new StringBuilder();
	362	kmd.append(abspieler.getUrl());
c6fdc4	363	//kmd.append(PL_CMD_PLAY);
U	364	kmd.append(abspielKmd);
1c5fa4	365	// Parameter fuer den Abspieler holen
ad3e2d	366	kmd.append(getEinstellung(s, getResString(RB_PLAYERPARAMS), PL_DEFAULT_PARAMS));
1c5fa4	367	kmd.append(server);
U	368	kmd.append(titelUrl);
	369
	370	return kmd;
	371	}
03b95f	372
005d7a	373	private void abspielerKommandoSenden(String kommando) {
U	374	/*
	375	TODO hier evtl. mit mehreren Versuchen ausgleichen,
	376	dass ein einzelner Versuch nicht 'durchkommt'...
	377	*/
	378	logger.info(kommando);
	379	try {
	380	HttpURLConnection conn = (HttpURLConnection) new URL(kommando).openConnection();
	381	conn.setRequestMethod("GET");
	382	conn.connect();
	383	int status = conn.getResponseCode();
	384	String msg = conn.getResponseMessage();
	385	logger.log(Level.INFO, "Kommando {0} mit Status {1} {2} gesendet.", new Object[]{kommando, status, msg});
	386	} catch(IOException ex) {
	387	logger.log(Level.INFO, ex.getMessage(), ex);
	388	}
	389	}
	390
5f7e0b	391	private String meldung(String text, int code) {
U	392	setReturnCode(code);
	393	return text;
	394	}
b56bb3	395	}