tango.git - Ulrich Hilger Code Repository

undisclosed

2023-01-02 792b21b74e40320c85e9a193c8fa8218851010e6

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