From c259d990ad63b38140985ba6e25b5046dd767833 Mon Sep 17 00:00:00 2001
From: ulrich
Date: Fri, 22 Nov 2024 08:16:48 +0000
Subject: [PATCH] Build-Anweisungen in Readme aktualisiert.
---
src/de/uhilger/tango/api/StreamHandler.java | 385 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 370 insertions(+), 15 deletions(-)
diff --git a/src/de/uhilger/tango/api/StreamHandler.java b/src/de/uhilger/tango/api/StreamHandler.java
index d19a82c..24bc407 100644
--- a/src/de/uhilger/tango/api/StreamHandler.java
+++ b/src/de/uhilger/tango/api/StreamHandler.java
@@ -1,22 +1,377 @@
package de.uhilger.tango.api;
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpExchange;
+import de.uhilger.tango.App;
+import de.uhilger.tango.Server;
+import static de.uhilger.tango.api.FileHandler.CONTENT_LENGTH;
+import static de.uhilger.tango.api.FileHandler.HTTP_GET;
+import static de.uhilger.tango.api.FileHandler.RANGE_HEADER;
+import static de.uhilger.tango.api.FileHandler.RB_NOT_FOUND;
+import static de.uhilger.tango.api.FileHandler.RB_WELCOME_FILE;
+import static de.uhilger.tango.api.FileHandler.SC_NOT_FOUND;
+import static de.uhilger.tango.api.FileHandler.SC_OK;
+import static de.uhilger.tango.api.FileHandler.STR_BLANK;
+import static de.uhilger.tango.api.FileHandler.STR_DOT;
+import de.uhilger.tango.entity.Ablageort;
+import de.uhilger.tango.entity.Abspielliste;
+import de.uhilger.tango.entity.Entity;
+import de.uhilger.tango.entity.Titel;
+import de.uhilger.tango.store.FileStorage;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
/**
- * Der StreamHandler liefert ganze Abspiellisten als einzelnen Stream aus.
- * Die in Tango mit dem ListHandler erstellen Abspiellisten werden als ein
- * zusammenhaengender Stream ausgegeben.
- *
- * HTTP GET /tango/api/stream/play/liste/[name]
- *
- * HTTP GET /tango/api/stream/pause/liste/[name]
- * HTTP GET /tango/api/stream/stop/liste/[name]
- * HTTP GET /tango/api/stream/seek/liste/[name]/[sekunden]
- *
- * Die Funktionen des StreamHandlers ergaenzen so die Ausgabe
- * einzelner Media-Dateien als Stream, wie sie mit dem FileHandler und
- * seinen Subklassen sowie mit der MediaSteuerung erfolgen.
- *
+ * Der StreamHandler liefert ganze Abspiellisten als einzelnen Stream aus. Die in Tango mit dem
+ * ListHandler erstellen Abspiellisten werden als ein zusammenhaengender Stream ausgegeben.
+ *
+ * Den Inhalt einer Abspielliste als Stream ausgeben HTTP GET /tango/api/stream/liste/[name]
+ *
+ *
+ *
+ *
+ * die folgenden URLs ggf. wieder wegnehmen
+ *
+ * HTTP GET /tango/api/stream/play/liste/[name]
+ *
+ * HTTP GET /tango/api/stream/pause/liste/[name] HTTP GET /tango/api/stream/stop/liste/[name] HTTP
+ * GET /tango/api/stream/seek/liste/[name]/[sekunden]
+ *
+ * Die Funktionen des StreamHandlers ergaenzen so die Ausgabe einzelner Media-Dateien als Stream,
+ * wie sie mit dem FileHandler und seinen Subklassen sowie mit der MediaSteuerung erfolgen.
+ *
* @author Ulrich Hilger
*/
-public class StreamHandler {
+public class StreamHandler extends FileHandler {
+ private static final Logger logger = Logger.getLogger(StreamHandler.class.getName());
+
+ public static final String PLAY = "play";
+ public static final String LISTE = "liste";
+
+ private HashMap listen;
+ private HashMap<String, File> files;
+ private HashMap<String, Long> bytes;
+ private HashMap<String, String> kataloge;
+ private String conf;
+
+ public StreamHandler(String conf) {
+ super(""); // wird spaeter gesetzt
+ listen = new HashMap<String, Integer>(); // abspiellistenname -> z.Zt. spielender Index
+ kataloge = new HashMap(); // url -> abs. pfad
+ files = new HashMap<String, File>(); // abspiellistenname -> z zt spielende datei
+ bytes = new HashMap<String, Long>(); // abspiellistenname -> gespielte bytes
+ this.conf = conf;
+ ablageorteLesen();
+ }
+
+ @Override
+ public void handle(HttpExchange e) throws IOException {
+ String path = e.getRequestURI().toString();
+ String[] elems = path.split(Server.SLASH);
+ String lName = elems[5];
+
+ Integer index;
+ File file;
+ FileStorage s = new FileStorage(conf);
+ Object o = listen.get(lName);
+ if (o instanceof Integer) {
+ // liste spielt schon
+ index = (Integer) o;
+ file = files.get(lName);
+ } else {
+ index = 0;
+ // liste spielt noch nicht
+ listen.put(lName, index);
+ file = getFileToPlay(s, lName, index.intValue());
+ files.put(lName, file);
+ bytes.put(lName, Long.valueOf(0));
+ }
+
+ //String fName = getFileName(e);
+ String fName = file.getName();
+ if (fName.startsWith(STR_DOT)) {
+ sendNotFound(e, fName);
+ } else {
+ Headers headers = e.getRequestHeaders();
+ int indexVal = index.intValue();
+ if (headers.containsKey(RANGE_HEADER)) {
+ logger.info("range header present, serving list file parts");
+ serveListParts(e, s, lName, file, indexVal);
+ //serveList(e, s, lName, file, indexVal);
+ } else {
+ //if (fName.length() < 1 || fName.endsWith(Server.SLASH)) {
+ // ResourceBundle rb = ResourceBundle.getBundle(App.RB_NAME);
+ // fName += getResString(RB_WELCOME_FILE);
+ //}
+
+ logger.info("no range header or header ignored, streaming whole files");
+ serveList(e, s, lName, file, indexVal);
+ //while(file != null) {
+ // files.put(lName, file);
+ // listen.put(lName, index);
+ // serveFile(e, file);
+ // file = getFileToPlay(s, lName, ++indexVal);
+ //}
+ }
+ }
+
+ /*
+ String response = lName;
+ Headers headers = e.getResponseHeaders();
+ headers.add("Content-Type", "application/json");
+ e.sendResponseHeaders(200, response.length());
+ OutputStream os = e.getResponseBody();
+ os.write(response.getBytes());
+ os.close();
+ */
+ }
+ private void serveListParts(HttpExchange e, FileStorage s, String lName, File file, int indexVal) throws IOException {
+ if (file.exists()) {
+ setHeaders(e, file);
+ //e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
+ //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
+ //e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
+ //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
+ //e.sendResponseHeaders(SC_PARTIAL_CONTENT, Long.MAX_VALUE);
+ logger.info("playing " + file.getName());
+ logger.info("file length: " + file.length());
+ InputStream is = new FileInputStream(file);
+ OutputStream os = e.getResponseBody();
+ while (file != null) {
+ //if(is instanceof InputStream) {
+ // is.close();
+ //}
+ //is = new FileInputStream(file);
+ files.put(lName, file);
+ listen.put(lName, indexVal);
+ file = serveFileParts(e, file, is, os, s, lName, indexVal);
+ //serveFile(e, file);
+ if(bytes.get(lName) == 0l) {
+ file = getFileToPlay(s, lName, ++indexVal);
+ if(is instanceof InputStream) {
+ is.close();
+ }
+ is = new FileInputStream(file);
+ logger.info("file length: " + file.length());
+ }
+ logger.info("playing " + file.getName());
+ }
+ //os.flush();
+ if(is instanceof InputStream) {
+ is.close();
+ }
+ logger.info("fertig os flush und close ");
+ os.flush();
+ os.close();
+ } else {
+ sendNotFound(e, file.getName());
+ }
+ logger.info("ende");
+ }
+
+
+
+ protected File serveFileParts(HttpExchange e, File file, InputStream is, OutputStream os, FileStorage s, String lName, int indexVal) throws IOException {
+ if (file.exists()) {
+ setHeaders(e, file);
+ //Long byteCount = bytes.get(lName);
+ //logger.info("byteCount at start: " + byteCount);
+ long responseLength = 0;
+ long start = 0;
+ long end;
+ String hdr;
+ RangeGroup rangeGroup = parseRanges(e, file);
+ Iterator<Range> i = rangeGroup.getRanges();
+ Headers resHeaders = e.getResponseHeaders();
+ while (i.hasNext()) {
+ Range range = i.next();
+ start = range.getStart();
+ //start = 0;
+ end = range.getEnd();
+ //end = file.length();
+ //responseLength += (end - start);
+ //start = 0;
+ //end = responseLength;
+ //range.setStart(start);
+ //range.setEnd(end);
+
+ hdr = contentRangeHdr(range, file);
+ resHeaders.add(CONTENT_RANGE_HEADER, hdr);
+ logger.info("added header " + hdr);
+ responseLength += (end - start);
+ }
+ logger.info("responseLength: " + responseLength);
+ e.sendResponseHeaders(SC_PARTIAL_CONTENT, responseLength);
+ //e.sendResponseHeaders(SC_PARTIAL_CONTENT, Long.MAX_VALUE);
+ //logger.info("responseHeaders gesendet ");
+ //if(HTTP_GET.equalsIgnoreCase(e.getRequestMethod())) {
+ //InputStream is = new FileInputStream(file);
+ //OutputStream os = e.getResponseBody();
+ //long streamPos = bytes.get(lName);
+ long count = 0;
+ if (start > 0) {
+ logger.info("skip to " + start);
+ is.skip(start);
+ }
+ int byteRead = is.read();
+ logger.info("starte while mit count=" + count);
+ while (/*byteRead > -1 && */ count < responseLength) {
+ ++count;
+ //++streamPos;
+ os.write(byteRead);
+ byteRead = is.read();
+ //logger.info("byteRead " + byteRead);
+ if(byteRead < 0 && count < responseLength) {
+ logger.info("dateiende, naechste Datei");
+
+ file = getFileToPlay(s, lName, ++indexVal);
+ if(file != null) {
+ logger.info("playing " + file.getName());
+ //streamPos = 0;
+ is.close();
+ is = new FileInputStream(file);
+ byteRead = is.read();
+ logger.info("neue Datei, count " + count + " responseLength " + responseLength);
+ logger.info("file length: " + file.length());
+ } else {
+ //logger.info("Liste zuende");
+ count = Long.MAX_VALUE;
+ logger.info("Liste zuende");
+ }
+ }
+ }
+ logger.info("while ende, count " + count);
+ //if(streamPos != responseLength) {
+ // bytes.put(lName, streamPos);
+ // logger.info("streamPos " + streamPos);
+ //} else {
+ // bytes.put(lName, Long.valueOf(0));
+ // logger.info("streamPos " + 0);
+ //}
+ //byteCount = count;
+
+ //logger.info("byteCount at end: " + byteCount);
+ //os.flush();
+ //os.close();
+ // is.close();
+ }
+ //} else {
+ // sendNotFound(e, file.getName());
+ //}
+ logger.info("ende");
+ return file;
+ }
+
+ protected String contentRangeHdr(Range range, File file) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(getResString(RB_BYTES));
+ sb.append(STR_BLANK);
+ sb.append(range.getStart());
+ sb.append(getResString(RB_DASH));
+ sb.append(range.getEnd());
+ sb.append(Server.SLASH);
+ //sb.append(file.length());
+ sb.append(Long.MAX_VALUE);
+ return sb.toString();
+ }
+
+
+
+ private void serveList(HttpExchange e, FileStorage s, String lName, File file, int indexVal) throws IOException {
+ if (file.exists()) {
+ setHeaders(e, file);
+ e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
+ //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
+ InputStream in = new FileInputStream(file);
+ OutputStream out = e.getResponseBody();
+ while (file != null) {
+ files.put(lName, file);
+ listen.put(lName, indexVal);
+ serveFile(e, file, in, out);
+ file = getFileToPlay(s, lName, ++indexVal);
+ }
+ out.flush();
+ out.close();
+ in.close();
+ } else {
+ sendNotFound(e, file.getName());
+ }
+ }
+
+ /**
+ * Den Inhalt einer Datei ausliefern
+ *
+ * @param e das Objekt mit Methoden zur Untersuchung der Anfrage sowie zum
+ * Anfertigen und Senden der Antwort
+ * @param file die Datei, deren Inhalt ausgeliefert werden soll
+ * @throws IOException falls etwas schief geht entsteht dieser Fehler
+ */
+ protected void serveFile(HttpExchange e, File file, InputStream in, OutputStream out) throws IOException {
+ logger.info("serving file " + file.getName());
+ //if(HTTP_GET.equalsIgnoreCase(e.getRequestMethod())) {
+ int b = in.read();
+ while (b > -1) {
+ out.write(b);
+ b = in.read();
+ }
+ logger.info("done serving file " + file.getName());
+ //in.close();
+ //out.flush();
+ //}
+ }
+
+
+
+ private File getFileToPlay(FileStorage s, String lName, int index) {
+ Entity entity = s.read(FileStorage.ST_ABSPIELLISTE, lName);
+ if (entity instanceof Abspielliste) {
+ Abspielliste liste = (Abspielliste) entity;
+ List<Titel> titelListe = liste.getTitel();
+ if(titelListe.size() > index) {
+ Titel t = titelListe.get(index);
+ String katalogUrl = t.getKatalogUrl();
+ String pfad = kataloge.get(katalogUrl);
+ return new File(pfad + t.getPfad(), t.getName());
+ } else {
+ return null;
+ }
+ } else {
+ // keine Abspielliste
+ return null;
+ }
+ }
+
+ private void ablageorteLesen() {
+ String typ = Ablageort.class.getSimpleName();
+ FileStorage store = new FileStorage(conf);
+ List<String> orte = store.list(typ);
+ Iterator<String> i = orte.iterator();
+ while (i.hasNext()) {
+ String ortName = i.next();
+ Entity e = store.read(typ, ortName);
+ if (e instanceof Ablageort) {
+ Ablageort ablageort = (Ablageort) e;
+ Logger logger = Logger.getLogger(StreamHandler.class.getName());
+ //logger.log(Level.FINE, "{0}{1}", new Object[]{ctx, ablageort.getUrl()});
+ logger.fine(ablageort.getOrt() + " " + ablageort.getUrl());
+ kataloge.put(ablageort.getUrl(), ablageort.getOrt());
+ //server.createContext(ctx + ablageort.getUrl(),
+ //new ListFileHandler(new File(ablageort.getOrt()).getAbsolutePath(), conf));
+ }
+ }
+ }
+
}
--
Gitblit v1.9.3