Работа с MediaPlayer в JavaFX

MediaPlayer mediaplayer = new MediaPlayer(mediafile);

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package project;
 
import javafx.application.Application;
import static javafx.application.Application.launch;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.stage.Stage;
import javafx.util.Duration;
import java.util.*;
import javax.swing.JFrame;
 
/**
 *
 * @author ill
 */
 
public class Project extends Application implements EventListener {
 
    Media mediafile = null;
    MediaPlayer mediaplayer = null;
    List<Media> arrMedia = new ArrayList<>();
    Duration CurrentTime;
    Duration TotalTime;
    JFrame PlayList = new JFrame("плейлист");
    Thread tp = new Thread();
    int tplayer = 0;
    
    
    @Override
    public void start(Stage primaryStage) {        
        View v  = new View();
        primaryStage.setTitle("JavaFX player");
        primaryStage.setScene(v.createView());
        primaryStage.setX(380);
        primaryStage.setY(380);
        primaryStage.show();
    }
    
    /**
     * The main() method is ignored in correctly deployed JavaFX application.
     * main() serves only as fallback in case the application can not be
     * launched through deployment artifacts, e.g., in IDEs with limited FX
     * support. NetBeans ignores main().
     *
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);        
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package project;
 
import java.io.File;
 
import java.util.List;
import java.util.Random;
import javafx.collections.MapChangeListener;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.stage.FileChooser;
import javafx.util.Duration;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ScrollPaneConstants;
 
/**
 *
 * @author ill
 */
public abstract class Player extends Project {
 
    /**
     * метод открытия звуковых файлов
     *
     * @return mediafile
     */
    public Media OpenMedia() {
        FileChooser fileChooser = new FileChooser();
        fileChooser.setTitle("открытие звукового файла");
        fileChooser.getExtensionFilters().addAll(
                new FileChooser.ExtensionFilter("Audio Files", " *.wav", "*.mp3", " *.wma", " *.aac"));
        List<File> arrFile = fileChooser.showOpenMultipleDialog(null);
        if (arrFile != null) {
            for (int i = 0; i < arrFile.size(); i++) {
                File file = arrFile.get(i);
                mediafile = new Media(file.toURI().toString());
                addArray();
            }
            mediafile = arrMedia.get(0);
            return mediafile;
        } else {
            return null;
        }
    }
 
    /**
     * метод воспроизведения звукового файла
     */
    public void StartPlay() {
        if (mediaplayer != null) {
            if (mediaplayer.getStatus() == MediaPlayer.Status.PAUSED) {
                mediaplayer.setStartTime(CurrentTime);
                mediaplayer.play();
            }
            if (mediaplayer.getStatus() == MediaPlayer.Status.STOPPED) {
                mediaplayer.stop();
                mediaplayer.setStartTime(Duration.ZERO);
                mediaplayer.play();
            }
        } else {
            while (mediafile == null) {
                OpenMedia();
            }
            mediaplayer = new MediaPlayer(mediafile);
            mediaplayer.play();
            this.setEvents();
        }
        System.out.println(mediaplayer.getStatus() + " " + CurrentTime + " " + Thread.currentThread().getName() + " play");
    }
 
    abstract protected void setEvents();
 
    /**
     * метод паузы воспроизведения
     */
    public void PausePlayer() {
        if (mediaplayer != null) {
            mediaplayer.pause();
            System.out.println(mediaplayer.getStatus() + " " + CurrentTime + " " + Thread.currentThread().getName() + " pause");
        }
    }
 
    /**
     * метод открытия плей листа
     */
    public void OpenPlayList() {
        if (!PlayList.isVisible()) {
            PlayList.setBounds(380, 520, 250, 300);
            int v = ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED;
            int h = ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED;            
            JScrollPane jsp = new JScrollPane(table, v, h);          
            PlayList.add(jsp);
            PlayList.setVisible(true);
        } else {
            PlayList.setVisible(false);
            PlayList.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        }
    }
    
    JTable table;
    TableModel tm = new TableModel(arrMedia);
 
    /**
     * метод остановки плеера
     */
    public void StopPlay() {
        if (mediaplayer != null) {
            CurrentTime = Duration.ZERO;
            mediaplayer.setStartTime(Duration.ZERO);
            mediaplayer.stop();
            System.out.println(mediaplayer.getStatus() + " " + CurrentTime + " " + Thread.currentThread().getName() + " stop");
        }
    }
 
    /**
     * метод преобразования Duration в минуты и секунды
     *
     * @return строку
     */
    public String Format(Duration d) {
        final int seconds = (int) (d.toMillis() / 1000) % 60;
        final int minutes = (int) (d.toMillis() / (1000 * 60));
        return String.format("%02d:%02d", minutes, seconds);
    }
    
    String mediatitle;
    String artist = null;
    String title = null;
    String dur = null;
 
    /**
     * метод добавления медиа файлов в коллекцию
     *
     */
    public void addArray() {
        arrMedia.add(mediafile);
        tm.setValueAt(mediafile);
        table = new JTable(tm);
        mediafile.getMetadata().addListener(new MapChangeListener<String, Object>() {
            @Override
            public void onChanged(MapChangeListener.Change<? extends String, ? extends Object> ch) {
                if (ch.wasAdded()) {
                    handleMetadata(ch.getKey(), ch.getValueAdded());
                }
            }
        });
    }
    
    int currFileIndex = 0;
 
    /**
     * метод выбора следующей композиции
     */
    public Boolean NextMedia(Boolean isRepeat, boolean isRandom) {
 
//        Thread th = Thread.currentThread();
//        ThreadGroup tg = th.getThreadGroup();
//        Thread active[] = new Thread[tg.activeCount() + 1];
//        int count = tg.enumerate(active);
//        for (int i = 0; i < count; i++) {
//            System.out.println("===" + active[i].getName());
//            if (active[i].getName().equals("JFXMedia Player EventQueueThread")) {
//                active[i].interrupt();
//                System.out.println("===" + active[i].getName());
//            }
//        }
        currFileIndex++;
        if (currFileIndex <= arrMedia.size() - 1) {
            if (isRandom) {
                Random r = new Random();
                mediafile = arrMedia.get(r.nextInt(arrMedia.size()));
                return true;
            } else {
                mediafile = arrMedia.get(currFileIndex);                
                return true;
            }
        } else {
            if (isRepeat) {
                if (isRandom) {
                    Random r = new Random();
                    mediafile = arrMedia.get(r.nextInt(arrMedia.size()));
                    System.out.println(mediafile.getMetadata().get("title"));
                    return true;
                }
                else {
                    currFileIndex = 0;
                    mediafile = arrMedia.get(0);                    
                    return true;
                }
            }
        }
        return false;
    }
 
    /**
     * метод выбора предыдущей композиции
     */
    public void BackMedia(Boolean isRepeat) {
 
        currFileIndex--;
        if (currFileIndex <= arrMedia.size() - 1) {
            mediafile = arrMedia.get(currFileIndex);
        } else {
            if (isRepeat) {
                currFileIndex = 0;
                mediafile = arrMedia.get(0);
            }
        }
    }
 
    /**
     *  обработка метаданных медиафайла
     * @param key
     * @param value 
     */
    private void handleMetadata(String key, Object value) {
 
        if (key.equals("artist")) {
            artist = value.toString();
        }
        if (key.equals("title")) {
            title = value.toString();
        }
        if (key.equals("duration")) {
            dur = Format((Duration) value);
        }
    }
 
    /**
     * метод отображения в окне названия композиции
     * @return строку
     */
    public String GetMediaName() {
 
        String m;
        if (mediafile.getMetadata().get("artist") != null && mediafile.getMetadata().get("title") != null) {
            m = mediafile.getMetadata().get("artist") + " - " + mediafile.getMetadata().get("title");
        } else {
            int lastIndexOf = mediafile.getSource().lastIndexOf("/");
            m = mediafile.getSource().substring(lastIndexOf + 1);
            m = m.replace("%", " ");
        }
        return m;
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package project;
 
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.Slider;
import javafx.scene.control.Tooltip;
import javafx.scene.effect.Blend;
import javafx.scene.effect.BlendMode;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.media.MediaPlayer;
import javafx.util.Duration;
 
/**
 *
 * @author ill
 */
public class View extends Player {
 
    final Label totalDuration = new Label("00:00");
    final Label currentTime = new Label("00:00");
    final Label mediaName = new Label(" ");
    final Slider positionSlider = new Slider(0.0, 1.0, 0.1);
    final CheckBox repeat = new CheckBox("rep");
    final CheckBox random = new CheckBox("ran");
    private Boolean isRewinded = false;
    private Boolean isEndMedia = false;
    private Boolean isTotal = true;    
 
    public Scene createView() {
        /**
         * Разметка окна кнопок воспроизведения
         */
        GridPane grid = new GridPane();
        grid.setAlignment(Pos.CENTER);
        grid.setHgap(10);
        grid.setVgap(10);
        grid.setPadding(new Insets(5, 5, 5, 5));
        grid.setGridLinesVisible(false);
 
        /**
         * описание кнопки предыдущий трек
         */
        Button back = new Button("back");
        back.setMinSize(50, 25);
        HBox hbback = new HBox(10);
        hbback.setAlignment(Pos.CENTER);
        repeat.setTooltip(new Tooltip("пердыдущий файл"));
        back.setEffect(new Blend(BlendMode.MULTIPLY));
        hbback.getChildren().add(back);
 
        /**
         * описание кнопки play
         */
        final Button play = new Button("play");
        play.setMinSize(50, 25);
        HBox hbplay = new HBox(10);
        play.setTooltip(new Tooltip("воспроизведение"));
        hbplay.setAlignment(Pos.CENTER);
        hbplay.getChildren().add(play);
 
        /**
         * описание кнопки pause
         */
        Button pause = new Button("pause");
        pause.setMinSize(50, 25);
        HBox hbpause = new HBox(10);
        pause.setTooltip(new Tooltip("пауза"));
        hbpause.setAlignment(Pos.CENTER);
        hbpause.getChildren().add(pause);
 
        /**
         * описание кнопки следующий трек
         */
        Button next = new Button("next");
        next.setMinSize(50, 25);
        HBox hbnext = new HBox(10);
        next.setTooltip(new Tooltip("следующий файл"));
        hbnext.setAlignment(Pos.CENTER);
        hbnext.getChildren().add(next);
 
        /**
         * описание кнопки следующий трек
         */
        Button stop = new Button("stop");
        stop.setMinSize(50, 25);
        HBox hbstop = new HBox(10);
        stop.setTooltip(new Tooltip("остановка"));
        hbstop.setAlignment(Pos.CENTER);
        hbstop.getChildren().add(stop);
 
        /**
         * описание кнопки следующий трек
         */
        Button open = new Button("open");
        open.setMinSize(50, 25);
        HBox hbopen = new HBox(10);
        open.setTooltip(new Tooltip("открытие файла"));
        hbopen.setAlignment(Pos.CENTER);
        hbopen.getChildren().add(open);
 
        /**
         * слайдер позиции воспроизведения
         */
        positionSlider.setId("positionSlider");
        positionSlider.setValue(0);
 
        /**
         * слайдер регулировки громкости воспроизведения
         */
        final Slider volumeSlider = new Slider(0.0, 1.0, 0.1);
        volumeSlider.setId("volumeSlider");
        HBox hbvsl = new HBox(10);
        volumeSlider.setLayoutX(50.0);
        volumeSlider.setValue(1.0);
        hbvsl.setAlignment(Pos.TOP_CENTER);
        hbvsl.getChildren().add(volumeSlider);
        
        /**
         * описание метки полная длительность файла 
         */
        totalDuration.setAlignment(Pos.CENTER_LEFT);
        totalDuration.setPrefSize(100, 75);
        HBox hblbt = new HBox(10);
        hblbt.setAlignment(Pos.CENTER_LEFT);
        hblbt.getChildren().add(totalDuration);
 
        /**
         * описание метки громкость
         */
        Label volume = new Label("громкость");
        volume.setAlignment(Pos.BOTTOM_CENTER);
        volume.setPrefSize(100, 25);
        HBox hblbv = new HBox(10);
        hblbv.setAlignment(Pos.BOTTOM_CENTER);
        hblbv.getChildren().add(volume);
 
        /**
         * описание метки текущее время воспроизведения файла
         */
        currentTime.setAlignment(Pos.CENTER_RIGHT);
        currentTime.setPrefSize(100, 75);
        HBox hblbc = new HBox(10);
        hblbc.setAlignment(Pos.CENTER_RIGHT);
        hblbc.getChildren().add(currentTime);
        
        /**
         * описание метки имя медиафайла
         */
        mediaName.setAlignment(Pos.TOP_LEFT);
        mediaName.setPrefSize(150, 25);
        HBox hblbn = new HBox(10);
        hblbn.setAlignment(Pos.TOP_LEFT);
        hblbn.getChildren().add(mediaName);
 
        /**
         * описание кнопки плей-лист
         */
        Button playlist = new Button("playlist");
        playlist.setAlignment(Pos.CENTER_LEFT);
        playlist.setMinSize(50, 25);
        HBox hbplaylist = new HBox(10);
        playlist.setTooltip(new Tooltip("открыть плейлист"));
        hbplaylist.setAlignment(Pos.CENTER_LEFT);
        hbplaylist.getChildren().add(playlist);
 
        /**
         * описание чекбокса на повтор
         */
        HBox hbrepeat = new HBox(10);
        hbrepeat.setAlignment(Pos.TOP_CENTER);
        repeat.setTooltip(new Tooltip("повтор плейлиста"));
        hbrepeat.getChildren().add(repeat);
 
        /**
         * описание чекбокса на случайное воспроизведение
         */
        HBox hbrandom = new HBox(10);
        hbrandom.setAlignment(Pos.TOP_CENTER);
        repeat.setTooltip(new Tooltip("случайное воспроизведение"));
        hbrandom.getChildren().add(random);
        
        /**
         * добавление контролов на сетку
         */
        grid.add(hbback, 1, 1,1,2);
        grid.add(hbplay, 3, 1,1,2);
        grid.add(hbpause, 4, 1,1,2);
        grid.add(hbnext, 5, 1,1,2);
        grid.add(hbstop, 2, 1,1,2);
        grid.add(hbopen, 6, 1,1,2);
        grid.add(hblbc, 0, 0,1,2);
        grid.add(hbplaylist, 0, 0);
        grid.add(hblbt, 6, 0);        
        grid.add(hblbv, 0, 1,1,2);
        grid.add(hbvsl, 0, 1,1,3);
        grid.add(hblbn, 1, 0, 5, 1);
        grid.add(hbrepeat, 4, 0);
        grid.add(hbrandom, 5, 0);
        grid.add(positionSlider, 1, 0, 5, 2);        
 
        /**
         * отображение окна
         */
        Scene scene = new Scene(grid, 500, 100);
 
        /**
         * вызов метода следующий трек
         */
        next.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent t) {
                isEndMedia = true;
                isTotal = true;
                while (tp.isAlive()) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(View.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    System.out.println("убей поток  " + mediafile.getSource());
                }
                CurrentTime = Duration.ZERO;
                currentTime.setText(String.format("%02d:%02d", 0, 0));
                positionSlider.setValue(0);
                StopPlay();
                mediaplayer = null;
                NextMedia(true, random.selectedProperty().getValue());
                isEndMedia = false;
                StartPlay();
            }
        });
        
        /**
         * вызов метода предыдущий трек
         */
        back.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent t) {
                isEndMedia = true;
                isTotal = true;
                while (tp.isAlive()) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(View.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    System.out.println("убей поток  " + mediafile.getSource());
                }
                CurrentTime = Duration.ZERO;
                currentTime.setText(String.format("%02d:%02d", 0, 0));
                positionSlider.setValue(0);
                StopPlay();
                mediaplayer = null;
                BackMedia(true);
                isEndMedia = false;
                StartPlay();
            }
        });
        
        /**
         * вызов метода воспроизведения
         */
        play.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                StartPlay();                
                mediaplayer.setVolume(volumeSlider.getValue());
                volumeSlider.valueProperty().bindBidirectional(mediaplayer.volumeProperty());
                isRewinded = false;
            }
        });
 
        /**
         * перемотка трека слайдером
         */
        positionSlider.setOnMouseClicked(new EventHandler<MouseEvent>() {
            @Override
            public void handle(MouseEvent t) {
                if (mediaplayer!=null) {
                    isRewinded = true;
                    System.out.println("starttime=" + TotalTime.multiply(positionSlider.getValue()).toMillis());                    
                    mediaplayer.seek(TotalTime.multiply(positionSlider.getValue()));
                    isRewinded = false;
                }
            }
        });
 
        /**
         * вызов метода кнопки пауза
         */
        pause.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                if (mediaplayer != null) {
                    CurrentTime = mediaplayer.getCurrentTime();
                    isRewinded = true;
                } else {
                    CurrentTime = Duration.ZERO;
                }
                PausePlayer();
            }
        });
 
        /**
         * вызов метода открытия файла
         */
        open.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                OpenMedia();
            }
        });
 
        /**
         * вызов метода кнопки стоп
         */
        stop.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                StopPlay();
                currentTime.setText(String.format("%02d:%02d", 0, 0));
                positionSlider.setValue(0);
                isRewinded = true;
            }
        });
 
        /**
         * вызов метода открытия плей листа
         */
        playlist.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                OpenPlayList();
            }
        });
 
        return scene;
    }
 
    /**
     * отображение слайдером и меткой текущего времени воспроизведения
     * по окончании файла вызывается следующий трек если он есть,
     * или начинается воспроизведени с начала плей листа, если стоит repeat
     */
    @Override
    protected void setEvents() {
        mediaplayer.setOnPlaying(new Runnable() {
            @Override
            public void run() {
                if (mediaplayer.getStatus() == MediaPlayer.Status.PLAYING) {
                    mediaName.setText(GetMediaName());
                    if (isTotal) {
                        TotalTime = mediaplayer.getTotalDuration();
                        totalDuration.setText(Format(mediaplayer.getTotalDuration()));                        
                        currentTime.setText(String.format("%02d:%02d", 0, 0));
                        isTotal = false;
                    }
                    if (!tp.isAlive()) {
                        tp = new Thread(new Runnable() {
                            @Override
                            public void run() {
                                while (mediaplayer != null && !isEndMedia) {
                                    if (isRewinded) {
                                        continue;
                                    }
                                    if (mediaplayer.getCurrentTime().toMillis() < TotalTime.toMillis()) {
 
                                        try {
                                            Thread.sleep(500);
                                        } catch (InterruptedException ex) {
                                            Logger.getLogger(View.class.getName()).log(Level.SEVERE, null, ex);
                                        }
                                        if (mediaplayer != null && mediaplayer.getTotalDuration() != null && mediaplayer.getCurrentTime() != null) {
                                            Platform.runLater(new Runnable() {
                                                @Override
                                                public void run() {
                                                    if (mediaplayer != null) {
                                                        currentTime.setText(Format(mediaplayer.getCurrentTime()));
                                                    } else {
                                                        currentTime.setText(String.format("%02d:%02d", 0, 0));
                                                    }
                                                }
                                            });
                                            positionSlider.setValue(mediaplayer.getCurrentTime().toMillis() / TotalTime.toMillis());
                                            //System.out.println(mediaplayer.getStatus() + " " + CurrentTime + " " + Thread.currentThread().getName() + " slider");
                                        } else {
                                            positionSlider.setValue(0);
                                        }
                                    }
                                }
                                isEndMedia = false;
                                Thread.currentThread().interrupt();
                            }
                        });
                    }
                    if (!tp.isAlive()) {
                        tp.setName("play");
                        tp.setDaemon(true);
                        tp.start();
                    }
                }
                System.out.println(mediaplayer.getStatus() + " " + CurrentTime + " " + Thread.currentThread().getName() + " playing");
            }
        });
        mediaplayer.setOnEndOfMedia(new Runnable() {
            @Override
            public void run() {
                tplayer++;
                isEndMedia = true;
                isTotal = true;
                while (tp.isAlive()) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(View.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    System.out.println("убей поток  " + mediafile.getSource());
                }
                CurrentTime = Duration.ZERO;
                currentTime.setText(String.format("%02d:%02d", 0, 0));
                positionSlider.setValue(0);
                StopPlay();
                mediaplayer = null;
                if (repeat.selectedProperty().getValue()) {
                    Boolean NextMedia = NextMedia(repeat.selectedProperty().getValue(), random.selectedProperty().getValue());
                    if (NextMedia) {
                        StartPlay();
                    } else {
                        CurrentTime = Duration.ZERO;
                        currentTime.setText(String.format("%02d:%02d", 0, 0));
                        positionSlider.setValue(0);
                        StopPlay();
                        mediaplayer = null;
                    }
                }
                System.out.println(CurrentTime + " " + Thread.currentThread().getName() + " endmedia");
                System.out.println(tplayer + " endmedia");
            }
        });
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package project;
 
import java.util.*;
import java.util.Observable;
import java.util.Observer;
import javafx.scene.media.Media;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
 
/**
 *
 * @author nina
 */
public class TableModel extends AbstractTableModel implements Observer {
 
    private Set<TableModelListener> listeners = new HashSet<TableModelListener>();
    private static final String[] columnName = {"Название", "Вермя"};
    private static List<Media> arrMedia;
    private Media mediafile;
 
    public TableModel(List<Media> arrMedia) {
        super();
        this.arrMedia = arrMedia;  
    }
 
    @Override
    public void addTableModelListener(TableModelListener listener) {
        listeners.add(listener);
    }
 
    @Override
    public Class<?> getColumnClass(int columnIndex) {
        return String.class;
    }
 
    @Override
    public String getColumnName(int col) {
        return columnName[col];
    }
 
    @Override
    public void removeTableModelListener(TableModelListener listener) {
        listeners.remove(listener);
    }
 
    @Override
    public int getRowCount() {
        return arrMedia.size();
    }
 
    @Override
    public int getColumnCount() {
        return columnName.length;
    }
 
    public void setValueAt(Media newData){
        arrMedia.add(newData);
        fireTableDataChanged();
    }
    
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        mediafile = arrMedia.get(rowIndex);
        String m = "";
        if (mediafile.getMetadata().get("artist")!=null && mediafile.getMetadata().get("title")!=null) {
            m = mediafile.getMetadata().get("artist") + " - " + mediafile.getMetadata().get("title");
        } else {
            int lastIndexOf = mediafile.getSource().lastIndexOf("/");
            m = mediafile.getSource().substring(lastIndexOf+1);
            m = m.replace("%", " ");
        }
        System.out.println(m);
        switch (columnIndex) {
            case 0:               
                return m;
            case 1:
                return null;
        }
        return null;
    }
 
    @Override
    public void update(Observable o, Object arg) {
        int index = arrMedia.indexOf(o);
        fireTableRowsUpdated(index, index);
    }
    
}

System.gc();

stage.getIcons().add(new Image("http://*******/sLKiSM"));