Ember Media Manager 1.4.8.0 Alpha - Diskussionsthread

Zitat von grieche47

Was ist denn mit dir los?!? Verstehe hier null was du sagen möchtest nur das emm nicht richtig läuft bei dir bzw mit Fehlern

Ja, merkt man, dass Dein Verständnis der Thematik arg eingeschränkt biszu gar nicht vorhanden ist.

Aber dann sollte man vielleicht erstmal den Ball flach halten und nicht gleich laut rumtönen?

Wie NadKP schon richtig erwähnt hatte, geht es hier um programminterne Dinge.

Ember benutzt ein Kodi Interface, dass nicht mehr so wirklich auf dem Laufenden ist und während des Übersetzungsvorgang fast 1500 böse Warnungen ausstösst. Aufgrund der Symmetrie der Warnungen hatte ich den Verdacht, als wenn das von niemandem Lebendigem programmiert worden sei, sondern maschinell von einem Code Generator ("ich schreibe Dir Dein Programm..") erzeugt worden ist.
Dann hatte ich den taktischen Fehler begangen, mich opfern zu wollen, die Warnungen zu beseitigen, angesichts der Masse schon eine böse, mehrwöchige, Fleißarbeit, aber der liebe Dannyboy hat mich "ganz harmlos" darum gebeten, den Code Generator selber zu "reparieren" und dabei so nebenbei "auf den aktuellen Stand" zu bringen.
Und eigentlich ist (war, vor der Rente) das auch genau mein Job, Compilerbau & Co sind meine Lieblingsprojekte.

Das besagte Teil habe ich mir dann heute mal angeguckt, es wurde zum letzten Male 2012 "gepflegt", also müsste ich mal eben alle Änderungen von Kodi von 2012 bis heute dort einbauen, in einer Sprache, die nicht wirklich zu meinen sattelfesten zählt, mit einer Zielvorgabe, von der ich keine Ahnung habe (selbst, wenn das Dingen mal wirklich wieder irgendwann durchlaufen sollte, kann ich nicht beurteilen, ob das Ergebnis "richtig" ist, oder nicht).
Der originale Programmierer hat wohl die Lust verloren, oder war mit dem erreichten Stand zufrieden...
Statt einer Wochenbeschäftigung entpuppt sich das Ganze also mehr als Lebensaufgabe, und da ich davon ausgehen muß, dass der, der den "harmlosen" Auftrag gab nun breit grinsend in einer Ecke sitzt und sich totlacht, gibts von mir den . (ich glaub auch, sein Grinsen ist noch viel, viel breiter, weil er da bestimmt auch mal reingeguckt hat und es dann aufgegeben hat...)

Also, reg Dich wieder ab, niemand hat von Ember geredet und grüss mir alle anderen Griechen

Zitat von grieche47

So, und wenn da nun im code , etwas falsch programmiert ist wo man, wie du schreibst tage/Wochen , braucht um das zu ändern, frag ich mich wieso du das Dan an den Kopf wirst. Ich finde was er macht hat Hand und Fuß und, Bugs werden gemeldet und dann gefixt.

Ich werfe nicht, höchstens mit Wattebäuschen
Und Dan ist da die richtige Zielperson, denn bis heute morgen wusste ich nicht, dass dieser Teil aus einer ganz anderen Quelle stammt und gar nicht zu Ember gehört. Insofern hat ihn auch niemand beachtet, oder, Dan hat beachtet, für "zu schwer" befunden und links liegen lassen. Weis ich nicht, aber, wenn nicht er, wer sonst ? .

Fakt ist aber, wenn ich mir die Mühe mache, es zum Laufen zu bekommen (bei sowas etwickle ich mit ausreichend Wut im Bauch einen sehr konstruktiven Ehrgeiz, das darf man nicht mit "sauer sein" verwechseln), dann wird einiges von dem, was Dan nun schon geändert hat, wieder hinfällig sein, und überarbeitet werden müssen. Auch nicht das Gelbe vom Ei.

DanCooper: (und alle Griechen wenden sich nun mit Grausen ab, denn nun wirds arg technisch !)
Kann es sein, dass jemand (aka DU) an den Ausgabedateien manuell rumgefuckelt hat?
Als Beispiel nehmen wir mal Addons.ExecuteAddons (ist so schön das allererste).

In Kodi definiert als (ich schreibs mal in VB )
function Addon.ExecuteAddons(AddonID as string (REQUIRED), Params as object=NULL, wait as boolean = false) as string

In Ember definiert als (C#)
public async Task<string> ExecuteAddon(XBMCRPC.Addons.ExecuteAddon_params1 params_arg, string addonid=null, bool wait=false)
+2 Überladungen
public async Task<string> ExecuteAddon(global::System.Collections.Generic.List<string> params_arg, string addonid=null, bool wait=false)
public async Task<string> ExecuteAddon(string params_arg, string addonid=null, bool wait=false)

Das Tool spuckt aber aus:
async public Task<string> ExecuteAddon(string addonid=null, bool wait=false);
async public Task<string> ExecuteAddon2(string addonid=null, string[] params_arg=null, bool wait=false)
async public Task<string> ExecuteAddon2(string addonid=null, string params_arg=null, bool wait=false)

Das hat ja nun so gar nichts miteinander zu tun...

Kann es sein, dass "jemand" die Ember Version manuell angepasst hat ?

Und wie soll ich die Funktionen "ExecuteAddon" und "ExecuteAddon2" jemals automatisch zusammenfassen ?

Irgendwas ist doch da gründlich verkehrt... klär mich auf!

Na ja, ich bin (natürlich?) schon ein wenig weiter, beisse aber jetzt langsam nur noch auf Granit

Die einfachen Syntaxprobleme und die bislang fehlenden Typen konnte ich ergänzen / umschiffen, aber dann traf mich der Oberhammer : "myExceptionNotYetImplemented".

Offensichtlich hat da jemand "dammals" aufgehört, als es anfing kompliziert zu werden. Bzw, Teile, die damals nicht erforderlich waren, wurden niemals umgesetzt.
Das Zeuch steckt gaaanz tief im Eingemachten, er schafft schon ein paar hundert Header einwandfrei zu generieren (na ja, "einwandfrei" ist noch etwas relativ, die neuen Typen setze ich erstmal als Kommentare ein und will dann sehen, ob sie überhaupt jemals benutzt werden, aber dafür muss der Kram ja zumindest ersmal komplett durchlaufen).

Du wirst sicherlich nicht alle Funktionen benötigen, sondern das Kodi Interface auf einen bestimmten Befehlssatz begrenzen.

Leider gehört wohl die aktuelle Baustelle, die mich zur Verzweiflung treibt, sicherlich dazu:

Videolibrary.SetEpisodeDetails(mit einer Gazillion (aka 21) von Parametern)

Das Problem dabei ist wohl, das die Anzahl der Parameter ihm das Gnick brechen, denn er möchte gerne für jede Variation eine überladene Funktion generieren.
Das wären dann mal eben 2^17-1 also 2097151 Funktionen....
Außerdem geht das dann noch gnadenlos in die Hose, da die meisten davon nicht unterscheidbare Parameter enthalten (also String1, String2 usw... da kann es keine funktionierende Überladung geben).
Ab einer gewissen Schachtelungstiefe kommt dann die Notbremse mit besagter ExceptionNotYetImplemented...

Vielleicht sollte man den ganzen Kram weglassen und stattdessen Deine so heißgeliebten (und, ich gebe zu, HIER MACHEN SIE WIRKLICH SINN!) Konstrukte "int?" usw verwenden?
Also keine Überladung, aber alle (bis auf die REQUIRED markierten) Parameter als nullable.
Dann hätten wir jeweils nur eine Funktion mit jeweils der maximalen Anzahl von Parameter.

Wie sehen denn die Aufrufe in Ember aus (bin zu faul zum Suchen, da frag ich doch lieber einen, der es wissen muss ) ? Verwendest Du Überladungen oder immer MaxParam?

(ein kurzer Scan zeigte mir, dass da noch so ca 20 NotYetImplemented auf mich warten, keine Ahnung, ob die auch noch irgendwann hochpoppen und ich jeweils wieder erraten darf, was der Dichter uns damit sagen wollte. Aber wie heißt es so schön bei Murphy: "hinter jedem großen Problem in der Programmierung warten noch hundert kleine darauf, rausgelassen zu werden..."

Achso: die Frage mit ExecuteAddon() und ExecuteAddon2() hat sich aufgeklärt: der Generator setzt immer eine "2" ans Ende, wenn er eine überladene Funktion generiert. Ist zwar Quatsch, aber zumindest hab ich schon mal die Stelle gefunden und kann sie auskommentieren (keine Ahnung, was das soll, erst mühsam Überladungen definieren, dann den Namen so verhunzen, dass sie nicht benutzbar sind...)

writer2.Write("        async public Task<");
                    writer2.Write(retType.Name);
                    writer2.Write("> ");
                    writer2.Write(methodName);
                    if (i > 0)
                    {
                        writer2.Write("2");
                    }
                    writer2.Write("(");
                    writer2.Write(parameters.GetParamList());
                    writer2.Write("");

ich hab übrigens doch schon ein paar Erweiterungen gefunden, die derzeit NICHT im Interface enthalten sind. Vor allen Dingen bei den Filtern sind neue Abfragen hinzugekommen, z.B. "userscore". Ob man die ein Ember brauchen kann, steht auf einem anderen Blatt.

Na ja, von A bis V komme ich ja schon W bis Z wird sich auch noch ergeben... aber derzeit bin ich wirklich ratlos.

Locutus von Borg, ääh, Cocutus , hat übrigens doch reichlich Hand angelegt, fast bekommt man den Eindruck, als würden die ganzen Funktionen des Generators gar nicht verwendet, sondern er führt seinen eigenen Serializer ein stattdessen.
Zumindest habe ich bislang noch keinen einzigen Aufruf der in der API definierten Methoden entdecken können. Nur die Klassen und Typen kommen zum Einsatz. Aber vielleicht bin ich auch blind, ist ne ganze Menge Holz der Teil und zudem noch in verschiedenen Sprachen, da kann man schon ins Grübeln kommen...

Ok, wer lange nagt, beißt endlich durch... Also der Kram hat sich jetzt vordringlich erstmal ergeben. Ich musste noch ein paar Stellen von NULL Pointern bewahren und liefere bei unbekannten (oder: nicht erkannten) Typen nun ganz braun "string" zurück, aber, zumindest läuft der Kram nun bis zum Ende durch und erzeugt alle Dateien.

Das muss erstmal noch nicht viel heißen, denn es kann ja auch großer Mist drinstehen. Wie also testen?

Hier mal ein Auszug (besagte böse Funktion, die dauernd ins Essen brach):

async public Task<string> SetTVShowDetails(int tvshowid=0, string title=null, int? playcount=null, string[] studio=null, string plot=null, string[] genre=null, double? rating=null, string mpaa=null, string imdbnumber=null, string premiered=null, string votes=null, string lastplayed=null, string originaltitle=null, string sorttitle=null, string episodeguide=null, string thumbnail=null, string fanart=null, string[] tag=null, XBMCRPC.Media.Artwork.Set art=null, int? userrating=null)
        {
            var jArgs = new JObject();
             if (tvshowid != null)
             {
                 var jproptvshowid = JToken.FromObject(tvshowid, _client.Serializer);
                 jArgs.Add(new JProperty("tvshowid", jproptvshowid));
             }
             if (title != null)
             {
                 var jproptitle = JToken.FromObject(title, _client.Serializer);
                 jArgs.Add(new JProperty("title", jproptitle));
             }
             if (playcount != null)
             {
                 var jpropplaycount = JToken.FromObject(playcount, _client.Serializer);
                 jArgs.Add(new JProperty("playcount", jpropplaycount));
             }
             if (studio != null)
             {
                 var jpropstudio = JToken.FromObject(studio, _client.Serializer);
                 jArgs.Add(new JProperty("studio", jpropstudio));
             }
             if (plot != null)
             {
                 var jpropplot = JToken.FromObject(plot, _client.Serializer);
                 jArgs.Add(new JProperty("plot", jpropplot));
             }
             if (genre != null)
             {
                 var jpropgenre = JToken.FromObject(genre, _client.Serializer);
                 jArgs.Add(new JProperty("genre", jpropgenre));
             }
             if (rating != null)
             {
                 var jproprating = JToken.FromObject(rating, _client.Serializer);
                 jArgs.Add(new JProperty("rating", jproprating));
             }
             if (mpaa != null)
             {
                 var jpropmpaa = JToken.FromObject(mpaa, _client.Serializer);
                 jArgs.Add(new JProperty("mpaa", jpropmpaa));
             }
             if (imdbnumber != null)
             {
                 var jpropimdbnumber = JToken.FromObject(imdbnumber, _client.Serializer);
                 jArgs.Add(new JProperty("imdbnumber", jpropimdbnumber));
             }
             if (premiered != null)
             {
                 var jproppremiered = JToken.FromObject(premiered, _client.Serializer);
                 jArgs.Add(new JProperty("premiered", jproppremiered));
             }
             if (votes != null)
             {
                 var jpropvotes = JToken.FromObject(votes, _client.Serializer);
                 jArgs.Add(new JProperty("votes", jpropvotes));
             }
             if (lastplayed != null)
             {
                 var jproplastplayed = JToken.FromObject(lastplayed, _client.Serializer);
                 jArgs.Add(new JProperty("lastplayed", jproplastplayed));
             }
             if (originaltitle != null)
             {
                 var jproporiginaltitle = JToken.FromObject(originaltitle, _client.Serializer);
                 jArgs.Add(new JProperty("originaltitle", jproporiginaltitle));
             }
             if (sorttitle != null)
             {
                 var jpropsorttitle = JToken.FromObject(sorttitle, _client.Serializer);
                 jArgs.Add(new JProperty("sorttitle", jpropsorttitle));
             }
             if (episodeguide != null)
             {
                 var jpropepisodeguide = JToken.FromObject(episodeguide, _client.Serializer);
                 jArgs.Add(new JProperty("episodeguide", jpropepisodeguide));
             }
             if (thumbnail != null)
             {
                 var jpropthumbnail = JToken.FromObject(thumbnail, _client.Serializer);
                 jArgs.Add(new JProperty("thumbnail", jpropthumbnail));
             }
             if (fanart != null)
             {
                 var jpropfanart = JToken.FromObject(fanart, _client.Serializer);
                 jArgs.Add(new JProperty("fanart", jpropfanart));
             }
             if (tag != null)
             {
                 var jproptag = JToken.FromObject(tag, _client.Serializer);
                 jArgs.Add(new JProperty("tag", jproptag));
             }
             if (art != null)
             {
                 var jpropart = JToken.FromObject(art, _client.Serializer);
                 jArgs.Add(new JProperty("art", jpropart));
             }
             if (userrating != null)
             {
                 var jpropuserrating = JToken.FromObject(userrating, _client.Serializer);
                 jArgs.Add(new JProperty("userrating", jpropuserrating));
             }
            var jRet = await _client.GetData<string>("VideoLibrary.SetTVShowDetails", jArgs);
            return jRet;
        }

Sieht m.E.n erstmal nicht total falsch aus, aber wer weis? (sind natürlich immer noch dieselben warnings drin, ich hab ja noch gar nix am output geändert sondern wäre erstmal froh, gesichert, dasselbe Ergebnis wie zuvor produzieren zu können).
Das es "neu" ist, erkennst Du am letzten Parameter "userrating", den gibts bislang in Ember noch nicht (bzw, den gabs im Output des Originaltools noch nicht, vielleicht wurde er ja manuell in Ember hinzugefügt? Hab ich nicht überprüft)

Sag nicht "mein", bislang habe ich immer noch nicht wirklich Ahnung, wie das Teil irgendwas tut, alle Arbeit bislang gingen nur in die Stellen ein, DAMIT das Teil überhaupt etwas tut, und nun konzentriere ich mich darauf, zu überprüfen, ob es etwas Sinnvolles tut...

Zitat von DanCooper

So kann ich im Kodi Interface immer alle Parameter setzen und die Kodi-API passt sie entsprechend der vom User verwendeten Kodi-Version an

Klingt erstmal kompliziert, ist aber relativ einfach mit Select Case API > 6.2 umsetzbar.

Nö, klingt nicht wirklich kompliziert, ist aber m.E.n unnötig.
Der ganze Kram wird ja serialisiert, und ich wette, dass die Kodiseite beim Auspacken ganz entspannt vorgeht. Unbkannte Parameter werden einfach ignoriert, genauso ist es beim Rücklesen, Felder, die die aktuelle API nicht kennt, werden bei einer Abfrage einfach nicht ausgeliefert. Käme auf einen einfachen Test an, probier doch mal aus, was passiert, wenn Du irgendeinen Unsinn mitsendest.

Insofern sollte es völlig ausreichen, immer die neueste API für einen Aufruf zu nehmen, die alten sollten dabei nicht ins Essen brechen.

Mehrere APIs parallel zu betreiben wird heilloses Chaos mit den Namen bringen, es sei denn, wir einigen uns zügig auf eine Nomenklatur a la <Methode><Version> also z.B. "ExecuteAddon632". (Sieht hässlich aus und Du kannst Dich schon mal auf fleißige Änderungen vorbereiten, molto Tippolo... bei jedem API Wechsel)

Anders siehts natürlich aus, wenn neue Methoden hinzukommen, die erst ab einen gewissen API Stand verfügbar sind. Allerdings könnte das dann im Einzelfall schwierig werden, wenn Ember sich viel Mühe in der Gui und den internen Funktionen gibt, um irgendeinen "tollen" Menüpunkt zu realisieren und ganz am Ende der Kette kriegt der Usah dann die Messagbox "Sorry, aber Ihr Kodi kann das hier noch nicht...".

Aber ich entnehme Deinen Ausführungen, dass Du als erste "Verbesserung" die API Version auslesen können möchtest? hängt ganz hinten an den Daten dran und wird im Moment einfach weggeschmissen. >> "version": "6.32.5"

Genausogut werden im Moment die vorhandene Kommentare der API einfach weggeschmissen, ich will versuchen, sie bei den Funktionen mit in den Source Code einzubauen. Im Moment hat die ja jemand händisch hinzugefügt (an manchen Stellen), aber warum tippen, wenn man nur kopieren muss?

Es ist eigentlich kein großes Problem, den ersten Parameter auch nullable zu machen oder beim Wert 0 (den ich nicht wirklich als gültig betrachte) einfach ein Return einzubauen gleich oben am Beginn einer Methode.

Zitat von Ashley

Aber beim Kodi Interface updatet sich bei mir garnichts Instant,

Hmm, vielleicht ein kleines Verständnisproblem bei der Bedienung ?

Also:
* Kodi starten und in die Ecke legen (sprich: NICHTS DAMIT TUN)
* Ember starten und in den Einstellungen sicherstellen, dass sowas da vorhanden ist:

(wobei Deine Kodiverbindung garantiert nicht "OCTOWIN10" heißt, aber die Haken sollten dieselben sein)
Damit das Ganze auch wirkt, müssen ZUSÄTZLICH bei FILME und (!) TV Serien noch diese Haken gesetzt sein:

So vorbereitet kann man einen ersten harmlosen Test starten:

* such Dir irgendwas (Film / Episode) in Ember aus, drück die rechte Maustaste, wähle Kodi Interface... und SYNCHRONISIEREN.
Ember wird Dir dann oben rechts einen "pending Task" anzeigen, aber bevor Du das lesen kannst, muss Kodi schon PLING! gemacht haben (und wenn man das Kodi Fenster gerade offen hatte steht da kurz ne Meldung "Ember Media Manager: akualisiert... <dein Film/Episodenname>"

Wenn das klappt, ist alle ok. Ansonsten überprüfe, ob Du in den Einstellungen von Ember z.b. die falsche IP Adresse / Portnummer / Username / Passwort eingetragen hast, oder bei Kodi vergessen hast, das Webinterface zu starten. Im dümmsten Falle steht dann irgendwo noch ein Firewall auf der Leitung rum und verhindert die Kommunikation. Also, eins nach dem anderen checken und neu probiere, bis es PLING! macht...

Aber immer wieder dran denken: KODI MUSS LAUFEN, sonst kann Ember nicht synchronisieren.