Synchronisieren Sie Ihre iTunes/Musik-Wiedergabelisten mit Android mit einem einfachen Bash-Skript

Besitzen Sie ein iPhone oder einen Mac, aber ein Android-Smartphone? Wenn es Ihnen wie mir geht, haben Sie vielleicht alle Ihre sorgfältig zusammengestellten Playlists in iTunes/Musik, aber es fällt Ihnen schwer, sie auf Ihr Android-Gerät zu übertragen. Nach Jahren des manuellen Erstellens von Playlists habe ich endlich eine Lösung gefunden: ein Bash-Skript, das Ihre Playlists automatisch von macOS auf Android exportiert und synchronisiert.

Hinweis: Dieses Skript löscht beim Synchronisieren des Musikordners automatisch alle Dateien in Ihrem Musikordner. Beachten Sie dies. Erstellen Sie daher vor der Ausführung eine Sicherungskopie. Die Verwendung erfolgt auf eigene Gefahr.

Was dieses Skript macht

Dieses Skript:

1. Extrahiert Wiedergabelisten direkt aus der Musik-App Ihres Mac (iTunes)
2. Exportiert sie als Standard-M3U-Wiedergabelistendateien
3. Synchronisiert optional sowohl die Wiedergabelisten als auch die eigentlichen Musikdateien mit Ihrem Android-Gerät
4. Merkt sich Ihre Einstellungen für das nächste Mal
5. Überträgt nur Dateien, die sich noch nicht auf Ihrem Gerät befinden (um Zeit zu sparen)

Installationsanweisungen

Haftungsausschluss: Dieses Skript eignet sich am besten für Entwickler oder technisch versierte Benutzer, die mit Terminalbefehlen vertraut sind. Die Verwendung erfolgt auf eigene Gefahr. Obwohl das Skript getestet wurde, kann ich nicht garantieren, dass es mit allen Setups einwandfrei funktioniert. Wie oben erwähnt, löscht es Ihre gesamte Musik auf Ihrem Android-Telefon.

Voraussetzungen:

• Ein Mac mit der Musik-App (früher iTunes)
• Ein Android-Gerät
• Android Debug Bridge (ADB) installiert

Installationsschritte:

1. Installieren Sie ADB falls Sie es noch nicht haben. Am einfachsten verwenden Sie Selbstgebrautes:
   brew install android-platform-tools
2. USB-Debugging aktivieren auf Ihrem Android-Gerät:
   • Gehen Sie zu Einstellungen > Über das Telefon
   • Tippen Sie 7 Mal auf „Build-Nummer“, um die Entwickleroptionen zu aktivieren
   • Gehen Sie zurück zu Einstellungen > System > Entwickleroptionen
   • Aktivieren Sie „USB-Debugging“.
3. Erstellen der Skriptdatei:
   • Terminal öffnen
   • Erstellen Sie mit Ihrem bevorzugten Texteditor eine neue Datei (ich verwende Nano):
     nano ~/music_playlist_sync.sh
   • Kopieren Sie das gesamte Skript und fügen Sie es ein (den Code unten in diesem Blog).
   • Speichern und beenden (drücken Sie in Nano Strg+O, dann Eingabe und dann Strg+X)
4. Machen Sie das Skript ausführbar:
5. chmod +x ~/music_playlist_sync.sh

Verwenden des Skripts

So führen Sie das Skript aus:

~/music_playlist_sync.sh

Wenn Sie es zum ersten Mal ausführen, führt das Skript Folgendes aus:

1. Alle verfügbaren Playlists aus Ihrer Musik-App anzeigen
2. Fragen Sie, welche Wiedergabeliste(n) Sie exportieren möchten (Sie können mehrere durch Kommas getrennte Zahlen auswählen)
3. Fragen Sie, wo Sie die exportierten Wiedergabelisten speichern möchten
4. Fragen Sie, ob Sie mit einem Android-Gerät synchronisieren möchten
5. Wenn ja, sucht es nach angeschlossenen Geräten und hilft beim Auffinden des Musikordners

Alle diese Einstellungen werden gespeichert, sodass Ihre Auswahl beim nächsten Ausführen des Skripts gespeichert wird.

Tipps zur Fehlerbehebung

Musik wird nach der Synchronisierung nicht angezeigt

Manchmal erkennt Android neu hinzugefügte Musikdateien nicht sofort. So erzwingen Sie einen erneuten Medienscan:

1. Installieren Sie eine App zum erneuten Scannen von Medien aus dem Google Play Store, z. B. „Rescan Media“ oder „SD Rescan“
2. Führen Sie die App aus, um einen erneuten Scan der Medienbibliothek auszulösen
3. Manchmal hilft ein Neustart des Telefons

Samsung-Telefone

Auf Samsung-Geräten müssen Sie die Wiedergabelisten möglicherweise manuell importieren:

1. Öffnen Sie die Samsung Music App
2. Gehen Sie zu Einstellungen > Wiedergabelisten > Wiedergabelisten importieren
3. Ihre neuen Wiedergabelisten sollten jetzt angezeigt werden

ADB-Verbindungsprobleme

Wenn das Skript Ihr Gerät nicht finden kann:

• Stellen Sie sicher, dass USB-Debugging aktiviert ist
• Versuchen Sie es mit einem anderen USB-Kabel (einige Kabel unterstützen nur das Laden)
• Entsperren Sie Ihr Telefon und akzeptieren Sie alle USB-Debugging-Eingabeaufforderungen
• Versuchen Sie zu laufen ADB-Geräte im Terminal, um zu überprüfen, ob Ihr Gerät erkannt wird

Wie es funktioniert

Das Skript verwendet AppleScript, um direkt mit der Musik-App zu kommunizieren und Playlist-Informationen zu extrahieren. Anschließend konvertiert es diese in Playlists im Standard-M3U-Format, die von den meisten Musikplayern gelesen werden können. Wenn Sie die Synchronisierung mit Android wählen, verwendet es ADB, um sowohl die Playlist-Dateien als auch die eigentlichen Musikdateien auf Ihr Gerät zu übertragen.

Aus Effizienzgründen behält es den Überblick darüber, welche Dateien bereits übertragen wurden, und synchronisiert nur neue oder geänderte Dateien.

Einschränkungen

• Das Skript funktioniert nur unter macOS mit der Musik-App
• Ihr Android-Gerät muss über USB angeschlossen sein und die Debugfunktion muss aktiviert sein
• Es werden keine Metadaten wie Wiedergabezahlen oder Bewertungen synchronisiert.
• Bei einer großen Musikbibliothek kann die erste Synchronisierung lange dauern.

Abschließende Gedanken

Dieses Skript hat mir stundenlange, mühsame Arbeit beim Neuerstellen meiner Playlists auf Android erspart. Es ist eine einfache Lösung für ein Problem, mit dem viele Nutzer mit gemischten Apple/Android-Systemen konfrontiert sind. Passen Sie es gerne Ihren individuellen Bedürfnissen an – der Code ist gut kommentiert, um die Anpassung zu erleichtern.

Wenn Sie es satt haben, auf mehreren Geräten separate Wiedergabelisten zu verwalten, probieren Sie dieses Skript aus und genießen Sie Ihre sorgfältig zusammengestellten Musiksammlungen auf Ihrem Android-Gerät!

Das Drehbuch

Nennen Sie es so etwas wie music_playlist_sync.sh

#!/bin/bash # Konfigurationsdateipfad im Home-Verzeichnis CONFIG_FILE="$HOME/.music_playlist_export.conf" # Häufige Android-Musikpfade zum Ausprobieren ANDROID_PATHS=( "/storage/emulated/0/Music" "/sdcard/Music" "/storage/sdcard0/Music" "/storage/sdcard1/Music" "/storage/self/primary/Music" ) # Funktion zum Bereinigen von Dateinamen sanitize_filename() { echo "$1" | sed 's/[^a-zA-Z0-9._-]/_/g' } # Überprüfen, ob adb installiert ist, wenn ! command -v adb &> /dev/null; dann echo "Fehler: ADB ist nicht installiert oder nicht in Ihrem PATH" echo "Bitte installieren Sie Android Debug Bridge (adb), um die Synchronisierungsfunktion zu verwenden" exit 1 fi # Geräteverbindung prüfen check_device() { echo "Suche nach verbundenen Android-Geräten …" devices=$(adb devices | grep -v "List" | grep "device$") if [ -z "$devices" ]; dann echo "Kein Android-Gerät gefunden. Bitte verbinden Sie Ihr Gerät mit aktiviertem USB-Debugging." exit 1 fi echo "Gerät verbunden." } # Android-Musikpfad automatisch erkennen detect_android_music_path() { echo "Android-Musikpfad wird erkannt …" for path in "${ANDROID_PATHS[@]}"; do exists=$(adb shell "[ -d \"$path\" ] && echo 'yes' || echo 'no'") if [ "$exists" = "yes" ]; then echo "Musikverzeichnis gefunden: $path" ANDROID_MUSIC_PATH="$path" return 0 fi done echo "Musikpfad konnte nicht automatisch erkannt werden. Es wird der Standardpfad verwendet." return 1 } # Wiedergabelisten direkt mit AppleScript abrufen echo "Wiedergabelisteninformationen werden von der Musik-App abgerufen …" playlist_output=$(osascript < <EOF
tell application "Music"
    set output to ""
    set playlists_list to user playlists
    repeat with i from 1 to count of playlists_list
        set pl to item i of playlists_list
        set pl_name to name of pl
        set output to output & pl_name & "|"
    end repeat
    return output
end tell
EOF
)

# Convert to array (macOS compatible)
IFS='|' read -r -a playlist_array <<< "$playlist_output"

# Check if we got any playlists
if [ ${#playlist_array[@]} -eq 0 ]; then
    echo "Error: No playlists found in Music app. Try using 'all playlists' instead of 'user playlists'."
    
    # Try again with all playlists
    echo "Trying with all playlists instead..."
    playlist_output=$(osascript <<EOF
tell application "Music"
    set output to ""
    set playlists_list to playlists
    repeat with i from 1 to count of playlists_list
        set pl to item i of playlists_list
        set pl_name to name of pl
        set output to output & pl_name & "|"
    end repeat
    return output
end tell
EOF
)
    
    # Convert to array (macOS compatible)
    IFS='|' read -r -a playlist_array << /dev/null) previous_dir=$(grep "^EXPORT_DIR=" "$CONFIG_FILE" | cut -d= -f2 2>/dev/null) previous_android_path=$(grep "^ANDROID_MUSIC_PATH=" "$CONFIG_FILE" | cut -d= -f2 2>/dev/null) fi # Benutzerauswahl mit Unterstützung für durch Kommas getrennte Werte abrufen, wenn [ -n "$previous_selection" ]; dann read -p "Geben Sie die zu exportierende(n) Playlistnummer(n) ein (durch Komma getrennt, wenn mehrere vorhanden sind) [$previous_selection]: " selection_input selection_input="${selection_input:-$previous_selection}" sonst read -p "Geben Sie die zu exportierende(n) Playlistnummer(n) ein (durch Komma getrennt, wenn mehrere vorhanden sind): " selection_input fi # Standard-Exportverzeichnis default_dir="${previous_dir:-$HOME/exported-playlists}" read -p "Geben Sie das Exportverzeichnis ein [$default_dir]: " user_dir export_dir="${user_dir:-$default_dir}" export_dir="${export_dir/#\~/$HOME}" # Fragen zur Android-Synchronisierung read -p "Mit Android-Gerät synchronisieren? (j/n): " android_sync wenn [[ "$android_sync" =~ ^[Yy]$ ]]; dann check_device # Versuchen Sie, den Android-Musikpfad zu ermitteln ANDROID_MUSIC_PATH="${previous_android_path:-${ANDROID_PATHS[0]}}" detect_android_music_path read -p "Geben Sie den Android-Musikpfad ein [$ANDROID_MUSIC_PATH]: " android_path ANDROID_MUSIC_PATH="${android_path:-$ANDROID_MUSIC_PATH}" # Erstellen Sie ein Wiedergabelistenverzeichnis auf dem Gerät adb shell "mkdir -p \"$ANDROID_MUSIC_PATH/Playlists\"" fi # Speichern Sie die Auswahl in der Konfigurationsdatei mkdir -p "$(dirname "$CONFIG_FILE")" echo "PLAYLIST_SELECTION=$selection_input" > "$CONFIG_FILE" echo "EXPORT_DIR=$export_dir" >> "$CONFIG_FILE" echo "LAST_RUN=$(Datum)" >> "$CONFIG_FILE" wenn [[ "$android_sync" =~ ^[Yy]$ ]]; dann echo "ANDROID_MUSIC_PATH=$ANDROID_MUSIC_PATH" >> "$CONFIG_FILE" fi # Verzeichnis erstellen, falls es nicht existiert mkdir -p "$export_dir" # Alle zu synchronisierenden Dateien ALL_MUSIC_FILES="$export_dir/.all_music_files.txt" > "$ALL_MUSIC_FILES" # Komma-getrennte Auswahlen verarbeiten IFS=',' read -r -a selections <<< "$selection_input" für Auswahl in "${selections[@]}"; do # Alle Leerzeichen entfernen selection=$(echo "$selection" | xargs) if [[ "$selection" =~ ^[0-9]+$ ]]; then index=$((selection-1)) if [ "$index" -ge 0 ] && [ "$index" -lt "${#playlist_array[@]}" ]; then selected_playlist="${playlist_array[$index]}" # Leere Playlistnamen überspringen if [ -z "$selected_playlist" ]; dann echo "Leere Playlist am Index $selection überspringen" weiter fi safe_name=$(sanitize_filename "$selected_playlist") output_path="$export_dir/${safe_name}.m3u" echo "Playlist exportieren: $selected_playlist" # Temporäre Datei für Titelpfade erstellen playlist_tracks="$export_dir/.playlist_tracks_${safe_name}.txt" # Titel direkt aus der Musik-App abrufen osascript > "$playlist_tracks" < <EOF
tell application "Music"
    set thePlaylist to (first playlist whose name is "$selected_playlist")
    set theOutput to ""
    repeat with aTrack in tracks of thePlaylist
        try
            if class of aTrack is file track then
                set trackLoc to location of aTrack
                if trackLoc is not missing value then
                    set trackPath to POSIX path of trackLoc
                    set theOutput to theOutput & trackPath & linefeed
                    log "Found track: " & trackPath
                end if
            end if
        on error errMsg
            log "Error processing track: " & errMsg
        end try
    end repeat
    return theOutput
end tell
EOF

            # Clean up the output file to ensure proper line breaks
            tr -d '\r' "$playlist_tracks.tmp" && mv "$playlist_tracks.tmp" "$playlist_tracks" # Zähle die Titel und zeige Debug-Informationen an track_count=$(grep -v "^$" "$playlist_tracks" | wc -l | tr -d ' ') echo "Debug: $track_count Titel in der Playlist gefunden" echo "Debug: Erste paar Titel:" head -n 3 "$playlist_tracks" # Erstelle die M3U-Datei echo "#EXTM3U" > "$output_path" cat "$playlist_tracks" >> "$output_path" echo "Erfolgreich: $track_count Titel nach $output_path exportiert" # Zur Liste der zu synchronisierenden Dateien hinzufügen cat "$playlist_tracks" >> "$ALL_MUSIC_FILES" # Android-Version erstellen, falls erforderlich, wenn [[ "$android_sync" =~ ^[Yy]$ ]] && [ "$track_count" -gt 0 ]; dann android_playlist="$ANDROID_MUSIC_PATH/Playlists/${safe_name}.m3u" android_m3u="$export_dir/android_${safe_name}.m3u" echo "#EXTM3U" > "$android_m3u" # Jeden Trackpfad mit besserer Fehlerbehandlung verarbeiten, während IFS= read -r track_path; do if [ -n "$track_path" ]; dann if [ -f "$track_path" ]; dann Dateiname=$(Basisname "$track_Pfad") echo "$ANDROID_MUSIC_PATH/$Dateiname" >> "$android_m3u" echo "Debug: Titel zur Android-Wiedergabeliste hinzugefügt: $Dateiname" sonst echo "Debug: Titeldatei nicht gefunden: $track_Pfad" fi fi fertig < "$playlist_tracks" # Prüfen, ob die Android-Wiedergabeliste Inhalt hat android_count=$(grep -v "^#" "$android_m3u" | grep -v "^$" | wc -l | tr -d ' ') wenn [ "$android_count" -gt 0 ]; dann echo "Android-Wiedergabeliste mit $android_count Titeln pushen …" adb push "$android_m3u" "$android_playlist" echo "Android-Wiedergabeliste erfolgreich erstellt" sonst echo "Keine gültigen Titel für Android-Wiedergabeliste" fi fi sonst echo "Ungültige Auswahl: $selection (außerhalb des gültigen Bereichs)" fi sonst echo "Ungültige Auswahl: $selection (keine Zahl)" fi fertig # Titel bei Bedarf synchronisieren, wenn [[ "$android_sync" =~ ^[Yy]$ ]]; dann echo "Musikdateien mit Android-Gerät synchronisieren …" # Musikverzeichnis auf dem Gerät erstellen adb shell "mkdir -p \"$ANDROID_MUSIC_PATH\"" # Eindeutige Titel abrufen und sicherstellen, dass sie vorhanden sind sort "$ALL_MUSIC_FILES" | uniq > "$ALL_MUSIC_FILES.unique" > "$ALL_MUSIC_FILES.valid" # Liste gültiger Dateien füllen echo "Gültige Musikdateien werden geprüft …" while IFS= read -r track_path; do if [ -n "$track_path" ] && [ -f "$track_path" ]; dann echo "$track_path" >> "$ALL_MUSIC_FILES.valid" fi done < "$ALL_MUSIC_FILES.unique" # Zähle die Gesamtzahl der Titel total_tracks=$(grep -v "^$" "$ALL_MUSIC_FILES.valid" | wc -l | tr -d ' ') echo "$total_tracks gültige Titel aus $(wc -l < "$ALL_MUSIC_FILES.unique" | tr -d ' ') eindeutigen Titeln gefunden" wenn [ "$total_tracks" -eq 0 ]; dann echo "Keine gültigen Titel zum Synchronisieren." sonst echo "$total_tracks gültige Titel zum Synchronisieren gefunden" echo "Debug: Erste 3 Titel zum Synchronisieren:" head -n 3 "$ALL_MUSIC_FILES.valid" echo "Synchronisierung der $total_tracks-Dateien wird gestartet..." current=0 # Verarbeite jeden Titel mit einem anderen Ansatz # Speichere zuerst die Titelpfade in einem Array track_paths=() while IFS= read -r line; do track_paths+=("$line") done < "$ALL_MUSIC_FILES.valid" echo "Debug: ${#track_paths[@]} Titel in den Speicher geladen" # Verarbeite jetzt jeden Titel im Array für track_path in "${track_paths[@]}"; do if [ -n "$track_path" ]; dann aktuell=$((aktuell + 1)) Dateiname=$(Basisname "$Track_Pfad") echo "[$aktuell/$Gesamt_Tracks] Synchronisation: $Dateiname" # Gründlichere Prüfung, ob Datei auf Gerät vorhanden ist file_exists=$(adb shell "wenn [ -f \"$ANDROID_MUSIC_PATH/$Dateiname\" ]; dann ls -l \"$ANDROID_MUSIC_PATH/$Dateiname\" | awk '{print \$5}'; sonst echo '0'; fi") lokale_Größe=$(stat -f%z "$Track_Pfad") echo "Lokale Größe: $lokale_Größe Bytes" echo "Remote-Größe: $Datei_existiert Bytes" wenn [ "$file_exists" != "0" ]; dann wenn [ "$file_exists" -eq "$local_size" ]; dann echo " Dateigröße stimmt überein, wird übersprungen..." sonst echo " Dateigröße stimmt nicht überein, wird neu synchronisiert..." adb push "$track_path" "$ANDROID_MUSIC_PATH/$filename" fi sonst echo " Datei auf Gerät nicht gefunden, wird übertragen..." wenn ! adb push "$track_path" "$ANDROID_MUSIC_PATH/$filename"; dann echo " Fehler beim Übertragen der Datei, wird mit der nächsten fortgesetzt..." weiter fi fi # Debug-Ausgabe wenn [ "$current" -eq 1 ]; dann echo " Erste Datei verarbeitet, wird fortgesetzt..." elif [ "$current" -eq 2 ]; dann echo "Zweite Datei verarbeitet, Fortsetzung..." elif [ "$current" -eq 3 ]; dann echo "Dritte Datei verarbeitet, Fortsetzung..." elif [ "$current" -eq 4 ]; dann echo "Vierte Datei verarbeitet, Fortsetzung..." elif [ "$current" -eq 5 ]; dann echo "Fünfte Datei verarbeitet, Fortsetzung..." fi fi done fi # Temporäre Dateien bereinigen rm -f "$ALL_MUSIC_FILES" "$ALL_MUSIC_FILES.unique" "$ALL_MUSIC_FILES.valid" fi echo "Alle Exporte nach $export_dir abgeschlossen" echo "Ihre Auswahl wurde gespeichert. Führen Sie dieses Skript erneut aus, um dieselben Einstellungen zu verwenden."

Zuletzt aktualisiert am 28. März 2025