org.jaudiotagger.tag.Tag Java Examples

public static Lyrics getLyrics(Context context, String artist, String title, boolean requestPermission) {
    String text = null;
    try {
        for (File file : getFiles(context, artist, title, requestPermission)) {
            AudioFile af = AudioFileIO.read(file);
            TagOptionSingleton.getInstance().setAndroid(true);
            Tag tag = af.getTag();
            text = tag.getFirst(FieldKey.LYRICS);
            if (!text.isEmpty()) {
                text = text.replaceAll("\n", "<br/>");
                break;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
    if (TextUtils.isEmpty(text))
        return null;
    Lyrics lyrics = new Lyrics(POSITIVE_RESULT);
    lyrics.setArtist(artist);
    lyrics.setTitle(title);
    lyrics.setText(text);
    lyrics.setSource("Storage");
    return lyrics;
}
 

@Override
protected Boolean doInBackground(Object... params) {
    Lyrics editedLyrics = (Lyrics) params[0];
    File musicFile = (File) params[1];
    boolean failed = false;

    if (musicFile != null)
        try {
            AudioFile af = AudioFileIO.read(musicFile);
            TagOptionSingleton.getInstance().setAndroid(true);
            Tag tags = af.getTag();
            tags.setField(FieldKey.ARTIST, editedLyrics.getArtist());
            tags.setField(FieldKey.TITLE, editedLyrics.getTitle());
            tags.setField(FieldKey.LYRICS, Html.fromHtml(editedLyrics.getText()).toString());
            af.setTag(tags);
            AudioFileIO.write(af);
        } catch (CannotReadException | IOException | ReadOnlyFileException | TagException
                | InvalidAudioFrameException | NullPointerException | CannotWriteException e) {
            e.printStackTrace();
            failed = true;
        }
    return failed;
}
 

public Image getArtwork() {
    if (this.artwork == null) {

        try {
            String location = this.songs.get(0).getLocation();
            AudioFile audioFile = AudioFileIO.read(new File(location));
            Tag tag = audioFile.getTag();
            byte[] bytes = tag.getFirstArtwork().getBinaryData();
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
            this.artwork = new Image(in, 300, 300, true, true);

            if (this.artwork.isError()) {
                this.artwork = new Image(Resources.IMG + "albumsIcon.png");
            }

        } catch (Exception ex) {
            this.artwork = new Image(Resources.IMG + "albumsIcon.png");
        }
    }
    return this.artwork;
}
 

/**
 * Parses meta data for the given music file. No guessing or reformatting is done.
 *
 *
 * @param file The music file to parse.
 * @return Meta data for the file.
 */
@Override
public MetaData getRawMetaData(File file) {

    MetaData metaData = new MetaData();

    try {
        AudioFile audioFile = AudioFileIO.read(file);
        Tag tag = audioFile.getTag();
        if (tag != null) {
            metaData.setAlbumName(getTagField(tag, FieldKey.ALBUM));
            metaData.setTitle(getTagField(tag, FieldKey.TITLE));
            metaData.setYear(parseYear(getTagField(tag, FieldKey.YEAR)));
            metaData.setGenre(mapGenre(getTagField(tag, FieldKey.GENRE)));
            metaData.setDiscNumber(parseInteger(getTagField(tag, FieldKey.DISC_NO)));
            metaData.setTrackNumber(parseTrackNumber(getTagField(tag, FieldKey.TRACK)));

            String songArtist = getTagField(tag, FieldKey.ARTIST);
            String albumArtist = getTagField(tag, FieldKey.ALBUM_ARTIST);
            metaData.setArtist(StringUtils.isBlank(songArtist) ? albumArtist : songArtist);
            metaData.setAlbumArtist(StringUtils.isBlank(albumArtist) ? songArtist : albumArtist);
        }

        AudioHeader audioHeader = audioFile.getAudioHeader();
        if (audioHeader != null) {
            metaData.setVariableBitRate(audioHeader.isVariableBitRate());
            metaData.setBitRate((int) audioHeader.getBitRateAsNumber());
            metaData.setDurationSeconds(audioHeader.getTrackLength());
        }


    } catch (Throwable x) {
        LOG.warn("Error when parsing tags in " + file, x);
    }

    return metaData;
}
 

private static Map<String, Float> parseId3Tags(Tag tag, String path) throws Exception {
  String id = null;

  if (tag.hasField("TXXX")) {
    id = "TXXX";
  } else if (tag.hasField("RGAD")) {    // may support legacy metadata formats: RGAD, RVA2
    id = "RGAD";
  } else if (tag.hasField("RVA2")) {
    id = "RVA2";
  }

  if (id == null) return parseLameHeader(path);

  Map<String, Float> tags = new HashMap<>();

  for (TagField field : tag.getFields(id)) {
    String[] data = field.toString().split(";");

    data[0] = data[0].substring(13, data[0].length() - 1).toUpperCase();

    if (data[0].equals("TRACK")) {data[0] = REPLAYGAIN_TRACK_GAIN;}
    else if (data[0].equals("ALBUM")) {data[0] = REPLAYGAIN_ALBUM_GAIN;}

    tags.put(data[0], parseFloat(data[1]));
  }

  return tags;
}
 

public static Bitmap getCover(Context context, String artist, String title, boolean requestPermission) {
    try {
        Tag tag = null;
        for (File file : getFiles(context, artist, title, requestPermission)) {
            AudioFile af = AudioFileIO.read(file);
            TagOptionSingleton.getInstance().setAndroid(true);
            tag = af.getTag();
            if (!tag.getArtworkList().isEmpty())
                break;
        }
        if (tag.getFirstArtwork() == null)
            return null;
        byte[] byteArray = tag.getFirstArtwork().getBinaryData();
        ByteArrayInputStream imageStream = new ByteArrayInputStream(byteArray);

        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(imageStream, null, options);

        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = wm.getDefaultDisplay();
        Point size = new Point();
        display.getSize(size);

        options.inJustDecodeBounds = false;
        options.inSampleSize = options.outWidth / size.x;

        return BitmapFactory.decodeStream(imageStream, null, options);
    } catch (Exception e) {
        return null;
    }
}
 

private String getTagField(Tag tag, FieldKey fieldKey) {
    try {
        return StringUtils.trimToNull(tag.getFirst(fieldKey));
    } catch (Exception x) {
        // Ignored.
        return null;
    }
}
 

@WorkerThread
public static void saveArtwork(Context context, int albumId, File artFile)
    throws TagException, ReadOnlyFileException, CannotReadException, InvalidAudioFrameException, IOException, CannotWriteException {
  Song song = MediaStoreUtil.getSongByAlbumId(albumId);
  if (song == null) {
    return;
  }
  AudioFile audioFile = AudioFileIO.read(new File(song.getUrl()));
  Tag tag = audioFile.getTagOrCreateAndSetDefault();
  Artwork artwork = ArtworkFactory.createArtworkFromFile(artFile);
  tag.deleteArtworkField();
  tag.setField(artwork);
  audioFile.commit();
  insertAlbumArt(context, albumId, artFile.getAbsolutePath());
}
 

public static void setReplayGainValues(Song song) {
  float rgTrack = 0.0f;
  float rgAlbum = 0.0f;

  Map<String, Float> tags = null;

  try {
    AudioFile file = AudioFileIO.read(new File(song.data));
    Tag tag = file.getTag();

    if (tag instanceof VorbisCommentTag) {
      tags = parseVorbisTags((VorbisCommentTag) tag);
    } else if (tag instanceof FlacTag) {
      tags = parseVorbisTags(((FlacTag) tag).getVorbisCommentTag());
    } else {
      tags = parseId3Tags(tag, song.data);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }

  if (tags != null && !tags.isEmpty()) {
    if (tags.containsKey(REPLAYGAIN_TRACK_GAIN)) {
      rgTrack = tags.get(REPLAYGAIN_TRACK_GAIN);
    }
    if (tags.containsKey(REPLAYGAIN_ALBUM_GAIN)) {
      rgAlbum = tags.get(REPLAYGAIN_ALBUM_GAIN);
    }
  }
  song.setReplayGainValues(rgTrack, rgAlbum);
}
 

public void setAlbumArt(File file, Bitmap artworkBitmap, Song song) throws IOException, TagException, ReadOnlyFileException, CannotReadException, InvalidAudioFrameException {

        artworkBitmap = Bitmap.createScaledBitmap(artworkBitmap, 500, 500, false);

        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        artworkBitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);

        byte[] byteArray = stream.toByteArray();

        File artworkFile = new File(Environment.getExternalStorageDirectory() + "/artwork.jpg");

        if (!artworkFile.exists())
            artworkFile.createNewFile();

        FileOutputStream out = new FileOutputStream(artworkFile);
        artworkBitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);

        Artwork artwork = Artwork.createArtworkFromFile(artworkFile);

        artwork.setBinaryData(byteArray);
        AudioFile audioFile = AudioFileIO.read(file);
        Tag tag = audioFile.getTagOrCreateAndSetDefault();


        if (tag.getFirstArtwork() != null) {
            tag.deleteArtworkField();
            tag.setField(artwork);
        } else {
            tag.addField(artwork);
        }

        Uri uri = MusicUtils.getAlbumArtUri(song._albumId);
        DiskCacheUtils.removeFromCache(uri.toString(), ImageLoader.getInstance().getDiskCache());
        String path = FileUtils.getRealPathFromURI(uri);
        new File(path).delete();
        artworkFile.delete();
    }
 

public static Artwork getArtwork(MediaFile file) {
    AudioFile audioFile;
    try {
        audioFile = AudioFileIO.read(file.getFile());
    } catch (Throwable e) {
        LOG.warn("Failed to find cover art tag in " + file, e);
        return null;
    }
    Tag tag = audioFile.getTag();
    return tag == null ? null : tag.getFirstArtwork();
}
 

private static String getTagField(Tag tag, FieldKey fieldKey) {
    try {
        return StringUtils.trimToNull(tag.getFirst(fieldKey));
    } catch (Exception x) {
        // Ignored.
        return null;
    }
}
 

private static String getTagField(Tag tag, FieldKey fieldKey) {
    try {
        return StringUtils.trimToNull(tag.getFirst(fieldKey));
    } catch (Exception x) {
        // Ignored.
        return null;
    }
}
 

private void fetchDetails() {
        File file = new File(SONG_PATH);

        try {
            AudioFile audioFile = AudioFileIO.read(file);
            Tag tag = audioFile.getTagOrCreateAndSetDefault();

            title = tag.getFirst(FieldKey.TITLE);

            mTitleEditText.setText(title);
            mTitleEditText.setSelection(title.length());

            artist = tag.getFirst(FieldKey.ARTIST);
            mArtistEditText.setText(artist);
            mArtistEditText.setSelection(artist.length());

            album = tag.getFirst(FieldKey.ALBUM);
            mAlbumEditText.setText(album);
            mAlbumEditText.setSelection(album.length());


            albumArtist = tag.getFirst(FieldKey.ALBUM_ARTIST);
            mAlbumArtistEditText.setText(albumArtist);
            mAlbumArtistEditText.setSelection(albumArtist.length());


            genre = tag.getFirst(FieldKey.GENRE);
            mGenreEditText.setText(genre);
            mGenreEditText.setSelection(genre.length());

            producer = tag.getFirst(FieldKey.PRODUCER);
            mProducerEditText.setText(producer);
            mProducerEditText.setSelection(mProducerEditText.length());

            year = tag.getFirst(FieldKey.YEAR);
            mYearEditText.setText(year);
            mYearEditText.setSelection(year.length());

            track = tag.getFirst(FieldKey.TRACK);
            mTrackEditText.setText(track);
            mTrackEditText.setSelection(track.length());


            totalTrack = tag.getFirst(FieldKey.TRACK_TOTAL);
            mTotalTrackEditText.setText(totalTrack);
            mTotalTrackEditText.setSelection(totalTrack.length());

            comment = tag.getFirst(FieldKey.COMMENT);
            mCommentsEditText.setText(comment);
            mCommentsEditText.setSelection(comment.length());


            List<Artwork> artwork = tag.getArtworkList();

            if (artwork.size() > 0) {
                byte[] image = artwork.get(0).getBinaryData();
                Bitmap bitmap = BitmapFactory.decodeByteArray(image, 0, image.length);
//                mCardView.setCardBackgroundColor(Palette.from(bitmap).generate().getC(R.color.deep_purple));
                mAlbumArtImage.setImageBitmap(bitmap);
            }
        } catch (CannotReadException | IOException | TagException | ReadOnlyFileException | InvalidAudioFrameException e) {
            e.printStackTrace();
            Toast.makeText(this, R.string.track_is_malformed, Toast.LENGTH_SHORT).show();
            finish();
        }
    }
 

/**
 * Parses meta data for the given music file. No guessing or reformatting is done.
 *
 *
 * @param file The music file to parse.
 * @return Meta data for the file.
 */
@Override
public MetaData getRawMetaData(Path file) {

    MetaData metaData = new MetaData();

    try {
        AudioFile audioFile = AudioFileIO.read(file.toFile());
        Tag tag = audioFile.getTag();
        if (tag != null) {
            metaData.setAlbumName(getTagField(tag, FieldKey.ALBUM));
            metaData.setTitle(getTagField(tag, FieldKey.TITLE));
            metaData.setYear(parseIntegerPattern(getTagField(tag, FieldKey.YEAR), YEAR_NUMBER_PATTERN));
            metaData.setGenre(mapGenre(getTagField(tag, FieldKey.GENRE)));
            metaData.setDiscNumber(parseIntegerPattern(getTagField(tag, FieldKey.DISC_NO), null));
            metaData.setTrackNumber(parseIntegerPattern(getTagField(tag, FieldKey.TRACK), TRACK_NUMBER_PATTERN));
            metaData.setMusicBrainzReleaseId(getTagField(tag, FieldKey.MUSICBRAINZ_RELEASEID));
            metaData.setMusicBrainzRecordingId(getTagField(tag, FieldKey.MUSICBRAINZ_TRACK_ID));

            metaData.setArtist(getTagField(tag, FieldKey.ARTIST));
            metaData.setAlbumArtist(getTagField(tag, FieldKey.ALBUM_ARTIST));

            if (StringUtils.isBlank(metaData.getArtist())) {
                metaData.setArtist(metaData.getAlbumArtist());
            }
            if (StringUtils.isBlank(metaData.getAlbumArtist())) {
                metaData.setAlbumArtist(metaData.getArtist());
            }

        }

        AudioHeader audioHeader = audioFile.getAudioHeader();
        if (audioHeader != null) {
            metaData.setVariableBitRate(audioHeader.isVariableBitRate());
            metaData.setBitRate((int) audioHeader.getBitRateAsNumber());
            metaData.setDuration(audioHeader.getPreciseTrackLength());
        }


    } catch (Throwable x) {
        LOG.warn("Error when parsing tags in " + file, x);
    }

    return metaData;
}
 

private Artwork getArtwork(MediaFile file) throws Exception {
    AudioFile audioFile = AudioFileIO.read(file.getFile());
    Tag tag = audioFile.getTag();
    return tag == null ? null : tag.getFirstArtwork();
}
 

private static int writeXML(File directory, Document doc, Element songs, int i) {
    File[] files = directory.listFiles();

    for (File file : files) {
        if (file.isFile() && isSupportedFileType(file.getName())) {
            try {

                AudioFile audioFile = AudioFileIO.read(file);
                Tag tag = audioFile.getTag();
                AudioHeader header = audioFile.getAudioHeader();

                Element song = doc.createElement("song");
                songs.appendChild(song);

                Element id = doc.createElement("id");
                Element title = doc.createElement("title");
                Element artist = doc.createElement("artist");
                Element album = doc.createElement("album");
                Element length = doc.createElement("length");
                Element trackNumber = doc.createElement("trackNumber");
                Element discNumber = doc.createElement("discNumber");
                Element playCount = doc.createElement("playCount");
                Element playDate = doc.createElement("playDate");
                Element location = doc.createElement("location");

                id.setTextContent(Integer.toString(i++));
                title.setTextContent(tag.getFirst(FieldKey.TITLE));
                String artistTitle = tag.getFirst(FieldKey.ALBUM_ARTIST);
                if (artistTitle == null || artistTitle.equals("") || artistTitle.equals("null")) {
                    artistTitle = tag.getFirst(FieldKey.ARTIST);
                }
                artist.setTextContent(
                        (artistTitle == null || artistTitle.equals("") || artistTitle.equals("null")) ? "" : artistTitle
                );
                album.setTextContent(tag.getFirst(FieldKey.ALBUM));
                length.setTextContent(Integer.toString(header.getTrackLength()));
                String track = tag.getFirst(FieldKey.TRACK);
                trackNumber.setTextContent(
                        (track == null || track.equals("") || track.equals("null")) ? "0" : track
                );
                String disc = tag.getFirst(FieldKey.DISC_NO);
                discNumber.setTextContent(
                        (disc == null || disc.equals("") || disc.equals("null")) ? "0" : disc
                );
                playCount.setTextContent("0");
                playDate.setTextContent(LocalDateTime.now().toString());
                location.setTextContent(Paths.get(file.getAbsolutePath()).toString());

                song.appendChild(id);
                song.appendChild(title);
                song.appendChild(artist);
                song.appendChild(album);
                song.appendChild(length);
                song.appendChild(trackNumber);
                song.appendChild(discNumber);
                song.appendChild(playCount);
                song.appendChild(playDate);
                song.appendChild(location);

                task.updateProgress(i, Library.maxProgress);

            } catch (Exception ex) {

                ex.printStackTrace();
            }

        } else if (file.isDirectory()) {

            i = writeXML(file, doc, songs, i);
        }
    }
    return i;
}
 

/**
 * Parses meta data for the given music file. No guessing or reformatting is done.
 *
 * @param file The music file to parse.
 * @return Meta data for the file.
 */
@Override
public MetaData getRawMetaData(File file) {

    MetaData metaData = new MetaData();

    try {
        AudioFile audioFile = AudioFileIO.read(file);
        Tag tag = audioFile.getTag();
        if (tag != null) {
            metaData.setAlbumArtist(getTagField(tag, FieldKey.ALBUM_ARTIST));
            metaData.setAlbumName(getTagField(tag, FieldKey.ALBUM));
            metaData.setArtist(getTagField(tag, FieldKey.ARTIST));
            metaData.setDiscNumber(parseInteger(getTagField(tag, FieldKey.DISC_NO)));
            metaData.setGenre(mapGenre(getTagField(tag, FieldKey.GENRE)));
            metaData.setMusicBrainzRecordingId(getTagField(tag, FieldKey.MUSICBRAINZ_TRACK_ID));
            metaData.setMusicBrainzReleaseId(getTagField(tag, FieldKey.MUSICBRAINZ_RELEASEID));
            metaData.setTitle(getTagField(tag, FieldKey.TITLE));
            metaData.setTrackNumber(parseIntegerPattern(getTagField(tag, FieldKey.TRACK), TRACK_NUMBER_PATTERN));
            metaData.setYear(parseIntegerPattern(getTagField(tag, FieldKey.YEAR), YEAR_NUMBER_PATTERN));

            if (StringUtils.isBlank(metaData.getArtist())) {
                metaData.setArtist(metaData.getAlbumArtist());
            }
            if (StringUtils.isBlank(metaData.getAlbumArtist())) {
                metaData.setAlbumArtist(metaData.getArtist());
            }

        }

        AudioHeader audioHeader = audioFile.getAudioHeader();
        if (audioHeader != null) {
            metaData.setVariableBitRate(audioHeader.isVariableBitRate());
            metaData.setBitRate((int) audioHeader.getBitRateAsNumber());
            metaData.setDurationSeconds(audioHeader.getTrackLength());
        }


    } catch (Throwable x) {
        LOG.warn("Error when parsing tags in " + file, x);
    }

    return metaData;
}
 

private static void createNewSongObject() {
	
	// Searches the xml file to get the last id assigned.
	int lastIdAssigned = xmlLastIdAssignedFinder();
	
	// Loops through each song file that needs to be added and creates a song object for each.
	// Each song object is added to an array list and returned so that they can be added to the xml file.
	for (File songFile : songFilesToAdd) {
        try {
            AudioFile audioFile = AudioFileIO.read(songFile);
            Tag tag = audioFile.getTag();
            AudioHeader header = audioFile.getAudioHeader();
            
            // Gets song properties.
            int id = ++lastIdAssigned;
            String title = tag.getFirst(FieldKey.TITLE);
            // Gets the artist, empty string assigned if song has no artist.
            String artistTitle = tag.getFirst(FieldKey.ALBUM_ARTIST);
            if (artistTitle == null || artistTitle.equals("") || artistTitle.equals("null")) {
                artistTitle = tag.getFirst(FieldKey.ARTIST);
            }
            String artist = (artistTitle == null || artistTitle.equals("") || artistTitle.equals("null")) ? "" : artistTitle;
            String album = tag.getFirst(FieldKey.ALBUM);
            // Gets the track length (as an int), converts to long and saves it as a duration object.                
            Duration length = Duration.ofSeconds((long) header.getTrackLength());
            // Gets the track number and converts to an int. Assigns 0 if a track number is null.
            String track = tag.getFirst(FieldKey.TRACK);                
            int trackNumber = Integer.parseInt((track == null || track.equals("") || track.equals("null")) ? "0" : track);
            // Gets disc number and converts to int. Assigns 0 if the disc number is null.
            String disc = tag.getFirst(FieldKey.DISC_NO);
            int discNumber = Integer.parseInt((disc == null || disc.equals("") || disc.equals("null")) ? "0" : disc);
            int playCount = 0;
            LocalDateTime playDate = LocalDateTime.now();
            String location = Paths.get(songFile.getAbsolutePath()).toString();
            
            // Creates a new song object for the added song and adds it to the newSongs array list.
            Song newSong = new Song(id, title, artist, album, length, trackNumber, discNumber, playCount, playDate, location);

            // Adds the new song to the songsToAdd array list.
            songsToAdd.add(newSong);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	// Updates the lastIdAssigned in MusicPlayer to account for the new songs.
	MusicPlayer.setLastIdAssigned(lastIdAssigned);
}
 

@Override
public void onReceive(final Context context, Intent intent) {
    XposedBridge.log("[SoundCloud Downloader] Entering album art downloader...");
    context.unregisterReceiver(this);

    XposedBridge.log("[SoundCloud Downloader] Unregistered receiver, starting Picasso...");
    Picasso.with(XposedMod.currentActivity).setLoggingEnabled(true); // enable logging to see why picasso fails to load
    Picasso.with(XposedMod.currentActivity).load(downloadPayload.getImageUrl()).into(new Target() {
        @Override
        public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
            try {
                File downloadedFile = new File(downloadPayload.getSaveDirectory(), downloadPayload.getFileName());
                if (!downloadedFile.exists()) {
                    XposedBridge.log("[SoundCloud Downloader] downloaded file does not exist, exiting...");
                    return;
                }

                TagOptionSingleton.getInstance().setAndroid(true);
                AudioFile audioFile = AudioFileIO.read(downloadedFile);
                Tag tag = audioFile.getTagOrCreateAndSetDefault();
                tag.setField(FieldKey.ARTIST,downloadPayload.getArtistName());
                tag.setField(FieldKey.GENRE, downloadPayload.getGenre());
                tag.setField(FieldKey.TITLE, downloadPayload.getTitle());
                tag.setField(FieldKey.ALBUM, downloadPayload.getTitle());

                ByteArrayOutputStream imgStream = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, imgStream);
                File artworkFile = File.createTempFile(downloadPayload.getTitle(), ".jpg");
                FileOutputStream artworkFileStream = new FileOutputStream(artworkFile);
                artworkFileStream.write(imgStream.toByteArray());
                artworkFileStream.close();
                artworkFile.deleteOnExit();
                imgStream.close();

                Artwork artwork = ArtworkFactory.createArtworkFromFile(artworkFile);
                artwork.setPictureType(3);
                tag.deleteArtworkField();
                tag.addField(artwork);
                tag.setField(artwork);

                audioFile.setTag(tag);
                AudioFileIO.write(audioFile);

                XposedBridge.log("[SoundCloud Downloader] Finished writing metadata...");

                XposedMod.currentActivity.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, Uri.fromFile(audioFile.getFile())));

                XposedBridge.log("[SoundCloud Downloader] Broadcasting update to media scanner...");

            } catch (Exception e) {
                XposedBridge.log("[SoundCloud Downloader] Metadata error: " + e.getMessage());
            }
        }

        @Override
        public void onBitmapFailed(Drawable errorDrawable) {
            XposedBridge.log("[SoundCloud Downloader] Album art fetch failed!");
        }

        @Override
        public void onPrepareLoad(Drawable placeHolderDrawable) {
            XposedBridge.log("[SoundCloud Downloader] Preparing to load picasso...");
        }
    });
}
 

public Artwork getArtwork(MediaFile file) throws Exception {
    AudioFile audioFile = AudioFileIO.read(file.getFile().toFile());
    Tag tag = audioFile.getTag();
    return tag == null ? null : tag.getFirstArtwork();
}