Drucken Sie die Wiedergabeliste von Google Play Music

Ich möchte eine Liste der Titel (mit Interpret, Album, Bewertung und, falls möglich, Anzahl der Wiedergaben und Dauer) von meinem Google Play Music- Konto aus drucken .

Es gibt keine einfache Möglichkeit, dies über die App zu tun. Es ist nicht haltbar, Druck-Screens zu machen, während ich durch eine lange Liste von Songs blättere.

Ich würde mich über einen Export von Daten in ein Standardformat (Klartext, CSV, XML usw.) freuen, das ich selbst manipulieren kann.

Irgendwelche Vorschläge?

Als ich die Antwort von darkliquid änderte , kam ich zu folgendem Ergebnis , mit dem mehrere Wiedergabelisten gleichzeitig gespeichert werden können .

Anleitung:

1. Gehen Sie zu Ihrer Wiedergabelistenseite .
2. Fügen Sie den folgenden JavaScript-Code in Ihre Konsole ein.
3. Klicken Sie auf eine Wiedergabeliste, die Sie als Text speichern möchten.
4. Scrollen Sie auf der Wiedergabelistenseite relativ langsam nach unten.
5. Navigieren Sie nach dem Scrollen nach unten mithilfe des Menüs oder der Zurück-Schaltfläche Ihres Browsers zur Wiedergabelistenseite (wie in Schritt 1 beschrieben).
6. Wiederholen Sie die Schritte 3 bis 5 für alle Wiedergabelisten, die Sie als Text speichern möchten.
7. Sobald Sie dies für alle Wiedergabelisten getan haben, die Sie als Text speichern möchten, können Sie entweder eingeben JSON.stringify(tracklistObj, null, '\t')(ändern '\t'in, ' 'wenn Sie einen minimalen Einzug wünschen) oder tracklistObjnur das JavaScript-Objekt so bearbeiten, wie Sie es möchten. Wenn Sie es sortieren möchten, führen Sie den Befehl aus, Object.values(tracklistObj).forEach(a => a.sort()) bevor Sie den Befehl aufrufen JSON.stringify.

Achten Sie darauf, die Seite nicht zu aktualisieren, bevor Sie alle gewünschten Schritte ausgeführt haben. Andernfalls müssen Sie einen Neustart ab Schritt 1 durchführen.

// Setup
var tracklistObj = {},
    currentPlaylist,
    checkIntervalTime = 100,
    lastTime;

// Process the visible tracks
function getVisibleTracks() {
    var playlist = document.querySelectorAll('.song-table tr.song-row');
    for(var i = 0; i < playlist.length ; i++) { 
        var l = playlist[i];

        var title = l.querySelector('td[data-col="title"] .column-content');
        if(title !== null)
            title = title.textContent;

        var artist = l.querySelector('td[data-col="artist"] .column-content');
        if(artist !== null)
            artist = artist.textContent;

        var duration = l.querySelector('td[data-col="duration"] span');
        if(duration !== null)
            duration = duration.textContent;

        var album = l.querySelector('td[data-col="album"] .column-content');
        if(album !== null)
            album = album.textContent;

        var playCount = l.querySelector('td[data-col="play-count"] span');
        if(playCount !== null)
            playCount = playCount.textContent;

        var rating = l.querySelector('td[data-col="rating"]');
        if(rating !== null)
            rating = rating.textContent;

        // Add it if it doesn't exist already
        if(tracklistObj[currentPlaylist] && !tracklistObj[currentPlaylist].includes(artist + " - " + title)) {
            tracklistObj[currentPlaylist].push(artist + " - " + title);

            if(printTracksToConsole) {
                console.log(artist + ' - ' + title);
            }
        }
    }
}

// Listen for page changes
window.onhashchange = function(e) {
    currentPlaylist = null; 

    var doneLoading = setInterval(function() {
        var playListName = document.querySelector('.gpm-detail-page-header h2[slot="title"]');
        if(playListName != null) {
            currentPlaylist = playListName.innerText;
            if(tracklistObj[currentPlaylist] === undefined) {
                tracklistObj[currentPlaylist] = [];
            }

            console.log("===================================");
            console.log("Adding to playlist " + currentPlaylist);

            getVisibleTracks();

            clearInterval(doneLoading);
        }
    }, 100);

}

// Check for new tracks every so often
setInterval(function() {
    getVisibleTracks();
}, checkIntervalTime);

// Whether or not to print the tracks obtained to the console
var printTracksToConsole = false;

Sie können auch Namen Spur auf der Konsole auszudrucken , wie Sie durch eine Änderung gehen printTracksToConsolezu true(Sie sollten diese vor dem 3. Schritt tun).

Beachten Sie, dass Sie wahrscheinlich alle GET- und POST-Fehler in der Konsole ignorieren können (diese werden von Play Music selbst generiert, nicht von diesem Skript).

Beachten Sie auch , dass derzeit nur es das Setup zu geben Artist - Track name, aber Sie können leicht die Linie bearbeiten, hat tracklistObj[currentPlaylist].push(artist + " - " + title);mit album, playCount, duration, oder ratingund / oder was auch immer Formatierungen , die Sie möchten (einschließlich CSV - Format , wenn Sie also bitte).

Beispielausgabe (alle Google Play-Wiedergabelisten, die ich derzeit habe) mit Standardeinstellungen. Insgesamt dauerte es ungefähr 5 Minuten, bis die 32 Wiedergabelisten angezeigt wurden. Scrollen Sie nach unten und konvertieren Sie das Ergebnis in Text.

_{PS Sie könnten an einer von mir gefundenen Website mit dem Namen " Tune My Music" interessiert sein , um YouTube-Wiedergabelisten (YouTube beschränkt die Erstellung von Wiedergabelisten auf 10 pro Tag) aus der Ausgabe zu erstellen, damit Ihre Freunde Ihre Google-Wiedergabelisten anhören können. In diesem Fall möchten Sie wahrscheinlich TextMechanic verwenden , um die Anführungszeichen und .mp3aus der ausgegebenen Liste zu entfernen .}

(Aktualisiert am 09.05.2016, robuster als die aktuelle Top-Antwort)

Wenn Sie nur ein paar Wiedergabelisten speichern müssen, können Sie einfach mein Javascript-Snippet unten verwenden. Mit diesem Snippet kann jede Liste so gespeichert werden, wie sie auf der Webseite angezeigt wird, sodass es auch für alle Ansichten der Musik- / Album- / Künstlerbibliothek funktioniert. Ich habe am Ende dieser Antwort zwei weitere Alternativen aufgelistet.

1. Gehen Sie zu: https://play.google.com/music/listen#/all (oder Ihrer Wiedergabeliste)

2. Öffnen Sie eine Entwicklerkonsole (F12 für Chrome). Fügen Sie den folgenden Code in die Konsole ein.

3. Alle gescrapten Songs werden im allsongsObjekt gespeichert und eine Textversion der Liste wird in die Zwischenablage kopiert. Ich empfehle, songsToText("all",true)danach auszuführen, um die vollständigen CSV-Informationen zu erhalten. Führen Sie copy(outText)manuell , wenn die Zwischenablage kopiert nicht beim ersten Versuch nicht funktioniert.

Code (neueste Version 10. Mai 2016, Rev. 30):

var allsongs = []
var outText = "";
var songsToText = function(style, csv, likedonly){
  if (style === undefined){
    console.log("style is undefined.");
    return;
  }
  var csv = csv || false; // defaults to false
  var likedonly = likedonly || false; // defaults to false
  if (likedonly) {
    console.log("Only selecting liked songs");
  }
  if (style == "all" && !csv){
    console.log("Duration, ratings, and playcount will only be exported with the CSV flag");
  }
  outText = "";
  if (csv) {
    if (style == "all") {
      //extra line
      outText = "artist,album,title,duration,playcount,rating,rating_interpretation" + "\n";
    } else if (style == "artist") {
    } else if (style == "artistsong") {
    } else if (style == "artistalbum") {
    } else if (style == "artistalbumsong") {
    } else {
      console.log("style not defined");
    }
  }
  var numEntries = 0;
  var seen = {};
  for (var i = 0; i < allsongs.length; i++) {
    var curr = "";
    var properTitle = allsongs[i].title.replace(/[\n\r!]/g, '').trim();
    if (!likedonly || (likedonly && allsongs[i].rating >= 5)){
      if (csv) {
        if (style == "all") {
          //extra line
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].duration.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].playcount.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating_interpretation.replace(/"/g, '""').trim() + '"';
        } else if (style == "artist") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbum") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbumsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else {
          console.log("style not defined");
        }
      } else {
        if (style == "all"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle + " [[playcount: " + allsongs[i].playcount + ", rating: " + allsongs[i].rating_interpretation + "]]" ;
        } else if (style == "artist"){
          curr = allsongs[i].artist;
        } else if (style == "artistalbum"){
          curr = allsongs[i].artist + " - " + allsongs[i].album;
        } else if (style == "artistsong"){
          curr = allsongs[i].artist + " - " + properTitle;
        } else if (style == "artistalbumsong"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle;
        } else {
          console.log("style not defined");
        }
      }
      if (!seen.hasOwnProperty(curr)){ // hashset
        outText = outText + curr + "\n";
        numEntries++;
        seen[curr] = true;
      } else {
        //console.log("Skipping (duplicate) " + curr);
      }
    }
  }
  console.log("=============================================================");
  console.log(outText);
  console.log("=============================================================");
  try {
    copy(outText);
    console.log("copy(outText) to clipboard succeeded.");
  } catch (e) {
    console.log(e);
    console.log("copy(outText) to clipboard failed, please type copy(outText) on the console or copy the log output above.");
  }
  console.log("Done! " + numEntries + " lines in output. Used " + numEntries + " unique entries out of " + allsongs.length + ".");
};
var scrapeSongs = function(){
  var intervalms = 1; //in ms
  var timeoutms = 3000; //in ms
  var retries = timeoutms / intervalms;
  var total = [];
  var seen = {};
  var topId = "";
  document.querySelector("#mainContainer").scrollTop = 0; //scroll to top
  var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    if (songs.length > 0) {
      // detect order
      var colNames = {
        index: -1,
        title: -1,
        duration: -1,
        artist: -1,
        album: -1,
        playcount: -1,
        rating: -1
        };
      for (var i = 0; i < songs[0].childNodes.length; i++) {
        colNames.index = songs[0].childNodes[i].getAttribute("data-col") == "index" ? i : colNames.index;
        colNames.title = songs[0].childNodes[i].getAttribute("data-col") == "title" ? i : colNames.title;
        colNames.duration = songs[0].childNodes[i].getAttribute("data-col") == "duration" ? i : colNames.duration;
        colNames.artist = songs[0].childNodes[i].getAttribute("data-col") == "artist" ? i : colNames.artist;
        colNames.album = songs[0].childNodes[i].getAttribute("data-col") == "album" ? i : colNames.album;
        colNames.playcount = songs[0].childNodes[i].getAttribute("data-col") == "play-count" ? i : colNames.playcount;
        colNames.rating = songs[0].childNodes[i].getAttribute("data-col") == "rating" ? i : colNames.rating;
      }
      // check if page has updated/scrolled
      var currId = songs[0].getAttribute("data-id");
      if (currId == topId){ // page has not yet changed
        retries--;
        scrollDiv = document.querySelector("#mainContainer");
        isAtBottom = scrollDiv.scrollTop == (scrollDiv.scrollHeight - scrollDiv.offsetHeight)
        if (isAtBottom || retries <= 0) {
          clearInterval(interval); //done
          allsongs = total;
          console.log("Got " + total.length + " songs and stored them in the allsongs variable.");
          console.log("Calling songsToText with style all, csv flag true, likedonly false: songsToText(\"all\", false).");
          songsToText("artistalbumsong", false, false);
        }
      } else {
        retries = timeoutms / intervalms;
        topId = currId;
        // read page
        for (var i = 0; i < songs.length; i++) {
          var curr = {
            dataid: songs[i].getAttribute("data-id"),
            index: (colNames.index != -1 ? songs[i].childNodes[colNames.index].textContent : ""),
            title: (colNames.title != -1 ? songs[i].childNodes[colNames.title].textContent : ""),
            duration: (colNames.duration != -1 ? songs[i].childNodes[colNames.duration].textContent : ""),
            artist: (colNames.artist != -1 ? songs[i].childNodes[colNames.artist].textContent : ""),
            album: (colNames.album != -1 ? songs[i].childNodes[colNames.album].textContent : ""),
            playcount: (colNames.playcount != -1 ? songs[i].childNodes[colNames.playcount].textContent : ""),
            rating: (colNames.rating != -1 ? songs[i].childNodes[colNames.rating].getAttribute("data-rating") : ""),
            rating_interpretation: "",
            }
          if(curr.rating == "undefined") {
            curr.rating_interpretation = "never-rated"
          }
          if(curr.rating == "0") {
            curr.rating_interpretation = "not-rated"
          }
          if(curr.rating == "1") {
            curr.rating_interpretation = "thumbs-down"
          }
          if(curr.rating == "5") {
            curr.rating_interpretation = "thumbs-up"
          }
          if (!seen.hasOwnProperty(curr.dataid)){ // hashset
            total.push(curr);
            seen[curr.dataid] = true;
          }
        }
        songs[songs.length-1].scrollIntoView(true); // go to next page
      }
    }
  }, intervalms);
};
scrapeSongs();
// for the full CSV version you can now call songsToText("all", true);

Letzter Code für Github (Gist) hier: https://gist.github.com/jmiserez/c9a9a0f41e867e5ebb75

• Wenn Sie die Ausgabe in einem Textformat wünschen, können Sie die Funktion songsToText () aufrufen. Sie können einen Style auswählen, das Format auswählen und wenn Sie möchten, sollten nur Songs exportiert werden. Die resultierende Liste wird dann in die Zwischenablage eingefügt. Styles sind all, artist, artistalbum, artistsong, artistalbumsong. CSV führt zu einer CSV-Datei und kann weggelassen werden (standardmäßig false). Likedonly kann weggelassen werden (Standard ist false) oder auf true gesetzt werden und filtert alle Songs mit Bewertungen größer oder gleich 5. Beispiel:

  • songsToText("all",true,false) exportiert alle songs im csv format.
  • songsToText("all",true,true) exportiert nur beliebte songs im csv format.
  • songsToText("artistsong",false,false) exportiert alle Lieder als Text.

• Sie können die Daten dann an einer beliebigen Stelle einfügen, z. B. http://www.ivyishere.org/, wenn Sie die Titel oder Alben zu Ihrem Spotify-Konto hinzufügen möchten. Verwenden Sie den "artistalbum" -Stil, damit Ivy vollständige Alben erkennt. Verwenden Sie für Songs den "artistsong" -Stil.

Über das Snippet: Dies basiert auf der ursprünglichen Antwort von Michael Smith, ist jedoch etwas robuster. Ich habe folgende Verbesserungen vorgenommen:

• Funktioniert sowohl mit Wiedergabelisten als auch mit der Bibliothek. Fehlende Spalten werden ignoriert und die Reihenfolge wird ermittelt. Daher sollte dies in fast jeder Songliste in Google Music funktionieren.

• Es stoppt entweder am unteren Rand (erkennt die Bildlaufposition) oder nach dem angegebenen Timeout. Das Timeout verhindert eine Endlosschleife, falls der Bildlauferkennungscode um einige Pixel abweicht.

• Es ist viel schneller (Intervall alle 1 ms), wartet aber, wenn die Daten nicht bereit sind (bis zum angegebenen Timeout, derzeit 3s).

• Deduplizierung während des Betriebs und auf der Ausgabe.

• Sammelt Bewertungen: "undefined" wird nie bewertet, "0" wird nicht bewertet (dh einmal bewertet, aber dann entfernt), "1" ist Daumen nach unten und "5" ist Daumen nach oben (gefällt).

Neben den grundlegenden Verbesserungen wird auch der Text schön formatiert und in die Zwischenablage kopiert. Sie können die Daten auch als CSV abrufen, indem Sie die songsToTextFunktion ein zweites Mal ausführen.

Alternativen:

1. Wenn Sie eine Python-API benötigen, lesen Sie das inoffizielle Google Music-API- Projekt.

2. Wenn Sie Unmengen von Wiedergabelisten haben und alle auf einmal exportieren möchten, probieren Sie den gmusic-scripts- Exporter für Wiedergabelisten aus, der dies ermöglicht (Python verwendet das inoffizielle API-Projekt).

Wenn es Ihnen nichts ausmacht, JavaScript-Code in der Entwicklerkonsole Ihres Browsers auszuführen, können Sie Informationen wie folgt aus der Seite extrahieren (nur in Chrome getestet):

var playlist = document.querySelectorAll('.song-table tr.song-row');
for(var i =0; i<playlist.length ; i++) { 
  var l = playlist[i]; 
  var title = l.querySelector('td[data-col="title"] .column-content').textContent;
  var artist = l.querySelector('td[data-col="artist"] .column-content').textContent;
  var album = l.querySelector('td[data-col="album"] .column-content').textContent;
  console.log(artist + ' --- ' + title + ' --- ' + album); 
}

Dadurch wird eine Liste der meisten derzeit im Fenster sichtbaren Titel auf der Konsole ausgedruckt. Sie müssen nach unten scrollen und es erneut ausführen, um mehr zu erhalten. Im Moment habe ich noch keine vernünftige Methode gefunden, um die Informationen in ihrer Gesamtheit zu erfassen, aber dieser schnelle 5-Minuten-Hack ist besser als nichts.

Unter Verwendung der (damaligen) Top-Antwort und der Suche nach einer vollständigen Lösung habe ich den folgenden Code erstellt, mit dem die Musikliste gescrollt und JSON-Objekte einem Array hinzugefügt werden.

Da nicht genau bekannt ist, welche Songs sichtbar sind, fügt der Code alle hinzu und dupliziert sie am Ende. (Nur in Chrome getestet.)

Verwendung: Gehen Sie zu Ihrer Bibliothek, wo Sie Ihre vollständige Songliste sehen, und führen Sie sie aus

var total = [];
var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    for (var i = 0; i < songs.length; i++) {
        total.push({name: songs[i].childNodes[0].textContent,
        length: songs[i].childNodes[1].textContent,
        artist: songs[i].childNodes[2].textContent,
        album: songs[i].childNodes[3].textContent,
        plays: songs[i].childNodes[4].textContent
        });
        songs[i].scrollIntoView(true);
    }
}, 800);

Wenn dies am Ende der Seite angezeigt wird, führen Sie dies aus, um den Bildlauf zu stoppen, das Array zu duplizieren und JSON in die Zwischenablage zu kopieren.

clearInterval(interval);
for (var i = 0; i < total.length; i++) {
    for (var j = i + 1; j < total.length; j++) {
        if (total.hasOwnProperty(i) && total.hasOwnProperty(j) && total[i].name == total[j].name && total[j].artist == total[i].artist) {
            total.splice(j,1);
        }
    }
}
copy(total);

Ich habe ein viel kürzeres JavaScript, das Sie in die Konsole einfügen können. Anstatt den Code erneut auszuführen, können Sie einfach nach unten scrollen und alle Alben, die angezeigt werden, werden hinzugefügt. Dann können Sie die Wiedergabeliste als Tabelle herunterladen.

Anleitung

1. Gehen Sie hier: https://play.google.com/music/listen#/ap/auto-playlist-thumbs-up

2. Öffnen Sie die Entwicklertools (F12) und fügen Sie den folgenden Code in die Registerkarte " Konsole" ein

3. Scrollen Sie, damit jedes Album in der Wiedergabeliste mindestens einmal sichtbar ist

4. Doppelklicken Sie auf die Seite, um sie herunterzuladen export-google-play.csv

5. export-google-play.csvIn Excel öffnen .

Code

alert("Please scroll through the playlist so that each album is visible once.\n" + 
      "Then double-click the page to export a spreadsheet.");
var albums = ["Artist,Album,Purchased"];

var addVisibleAlbums = function(){
    [].forEach.call(document.querySelectorAll(".song-row"), function(e){ 
        var albumNodes = [e.querySelector("td[data-col='artist']"), 
              e.querySelector("td[data-col='album']"),
              e.querySelector("td[data-col='title'] .title-right-items")];

        var albumString = albumNodes.map(function(s){ 
            return s.innerText.trim().replace(/,/g,""); 
        }).join(",");

        if(albums.indexOf(albumString) === -1){
            albums.push(albumString); console.log("Added: " + albumString)
        }
    });
}

var createCsv = function(){
    var csv = "data:text/csv;charset=utf-8,";
    albums.forEach(function(row){ csv += row + "\n"; }); 

    var uri = encodeURI(csv);
    var link = document.createElement("a");
    link.setAttribute("href", uri);
    link.setAttribute("download", "export-google-play.csv");
    document.body.appendChild(link);
    link.click(); 
    alert("Download beginning!")
}

document.body.addEventListener("DOMNodeInserted", addVisibleAlbums, false);
document.body.addEventListener("dblclick", createCsv, false);

Ausgabe

GitHub

Ich habe den Ansatz der Top-Antwort ein wenig geändert. Dies funktionierte besser für mich mit der Copy / Paste-Methode von Ivy ( http://www.ivyishere.org/ivy ):

Schritt 1 Öffnen Sie die gewünschte Wiedergabeliste von Google Music in Chrome und fügen Sie diese in die Konsole ein:

document.querySelector('body.material').style.height = (document.querySelector('table.song-table tbody').getAttribute('data-count') * 100) + 'px';

Dies sollte dazu führen, dass Ihre gesamte Wiedergabeliste gerendert wird und nicht nur ein Teil.

Schritt 2 Fügen Sie dieses Skript in die Konsole ein:

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('td[data-col="title"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);

Schritt 3 Wechseln Sie zu Ivy. Wenn Sie dort zu Schritt 2 gelangen, wählen Sie die Registerkarte Kopieren / Einfügen und fügen Sie die Konsolenausgabe dort ein.

BEARBEITEN

Aktualisiertes Skript von Alex Pedersen

Iterieren auf samurauturetskys Verfeinerung (Ich habe noch nicht genug Ruf, um seinen Beitrag zu kommentieren). Ich denke, das Googleplay-Design wurde aktualisiert, sodass das folgende Skript wieder eine hübsche Ausgabe liefert.

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('span[class="column-content fade-out tooltip"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);

Tun Sie einfach Ctrl+, –bis der Text sehr klein ist, und wählen Sie dann den gesamten Text aus. Es funktioniert wie ein Zauber ohne Skripte und Apps.

Ich bin gerade auf diese Frage gestoßen und habe nach etwas Ähnlichem gesucht.

Ich denke, Ihre beste Option ist:

1. installiere eine App wie "Playlist Backup"
2. Exportieren Sie die Google Music Playlist mit dieser App in eine Textdatei.
3. Benenne es mit einer FileManager-App (wie Ghost Commander) in .m3u um
4. Öffnen Sie die Wiedergabeliste mit einer anderen App mit mehr Optionen (z. B. MusiXMatch).