audio-vis/raw/javascript/player.js

class Player {
    async init() {
        this.playlist = new Playlist();
    }

    nextSong() {
        let next = this.playlist.getNext();
        audioHandler.loadSong(next);
    }

    prevSong() {
        let next = this.playlist.getPrevious();
        audioHandler.loadSong(next);
    }

    playStop() {
        if (!audioHandler.lastSong) {
            let next = this.playlist.getCurrent();
            audioHandler.loadSong(next);
            return;
        }
        let audioFile = audioHandler.audioFile;
        if (audioFile.paused) {
            audioFile.play();
        } else {
            audioFile.pause();
        }
        window.dispatchEvent(new CustomEvent('playSong'));
    }

    playByID(number) {
        this.playlist.index = number;
        let next = this.playlist.getCurrent();
        audioHandler.loadSong(next);
    }
}

const PAGINATIONLIMIT = 50;

class Playlist {
    constructor() {
        this.list = [];
        this.shuffled = [];
        this.index = 0;
        this.page = 0;
        this.isShuffle = false;
        $('body').addDelegatedEventListener('change', 'input[type="file"]', this.changeFiles.bind(this));
        $('body').addDelegatedEventListener('click', '.pagination .item', this.handlePagination.bind(this));
        eventHandler.addEvent('id3-request', this.handle.bind(this));
        eventHandler.addEvent('id3-request-force', this.forceID3.bind(this));
    }

    shuffle() {
        // only shuffle if more then 2 elements are in
        let len = this.list.length;
        if (len < 3) {
            this.shuffled = [0, 1, 2];
            return;
        }
        // the current-list need to be shuffled...
        for (let i = 0; i < len; i++) {
            let random = VTUtils.randomInt(0, len - 1);
            this.swap(i, random);
        }
    }

    swap(a, b) {
        this.shuffled[a] = b;
        this.shuffled[b] = a;
    }

    getNext() {
        let items = this.list,
            len = items.length - 1,
            next = this.index + 1;
        if (next > len) {
            next = 0;
        }
        this.index = next;
        return items[this.getRealIndex()];
    }

    getPrevious() {
        let items = this.list,
            len = items.length - 1,
            next = this.index - 1;
        if (next < 0) {
            next = len;
        }
        this.index = next;
        return items[this.getRealIndex()];
    }

    getCurrent() {
        return this.list[this.getRealIndex()];
    }

    // on new upload... this has to be an array!
    setPlaylist(files) {
        this.index = 0;
        this.forceData = undefined;
        this.list = files;
        this.shuffle();
    }

    handlePagination(event, el) {
        if (el.hasClass('inactive')) {
            return;
        }
        if (el.hasClass('next-site')) {
            this.renderPagination(this.page + 1);
        } else {
            this.renderPagination(this.page - 1);
        }
    }

    renderPagination(page) {
        if (page === undefined) {
            page = this.page;
        }
        let length = this.list.length,
            maxSite = Math.ceil(length / PAGINATIONLIMIT) - 1;
        if (page < 0) {
            page = 0;
        }
        if (page > maxSite) {
            page = maxSite;
        }
        let s = page * PAGINATIONLIMIT,
            e = s + PAGINATIONLIMIT,
            data = "";
        this.page = page;
        if (e >= length) {
            e = length;
        }
        if (length > 0) {
            let items = this.list;
            for (let i = s; i < e; i++) {
                let obj = {
                    index: i.toString(),
                    nr: i + 1,
                    title: items[this.getRealIndex(i)].getAudioName(),
                    active: !audioHandler.audioFile.paused && i === this.index ? 'active' : ''
                }
                data += template.parseTemplate("playlist-item", obj);
            }
        } else {
            data = "<h1>No Songs uploaded!</h1>";
        }
        let hasNext = maxSite > 1 && page < maxSite;
        gui.modal.renderModal(
            "Playlist",
            template.parseTemplate("playlist", {
                content: data,
            }),
            template.parseTemplate('playlist-footer', {
                prevActive: page > 0 ? 'active' : 'inactive',
                nextActive: hasNext ? 'active' : 'inactive',
                page: (page + 1) + ' / ' + parseInt(maxSite + 1),
            })
        );
    }

    //playlist handler for file input!
    changeFiles(e, el) {

        if (el.id !== 'upload-dir') {
            return;
        }
        let files = [];
        let i = 0;
        for (let file of el.files) {
            if (file && file.type.indexOf('audio') !== -1 && file.name.match(".m3u") === null) {
                let audioFile = new AudioPlayerFile(file, i++);
                files.push(audioFile);
            }
        }
        this.setPlaylist(files);
        if (files.length > 0) {
            NotificationHandler.createNotification("Songs added successfully!<br> Songs: " + files.length, "success", 3000);
            this.renderPagination(0);
        } else {
            NotificationHandler.createNotification("File Upload failed!", "error", 3000);
        }
    }

    getRealIndex(index) {
        if (index === undefined) {
            index = this.index;
        }
        if (this.isShuffle) {
            return this.shuffled[index];
        }
        return index;
    }

    handle(data) {
        let index = data.index;
        if (data.status === "waiting") {
            return;
        }
        this.list[index].id3 = data;
        if (this.timeout) {
            window.clearTimeout(this.timeout);
        }
        this.timeout = setTimeout(this.renderPagination.bind(this), 100);
    }

    forceID3(data) {
        let self = this;
        if (!self.forceData) {
            self.forceData = {};
            self.forceNotification = NotificationHandler.createNotification("TagReader -> 0 / " + self.list.length, "info", -1);
        }
        let index = data.index;
        if (data.status === "waiting") {
            return;
        }
        self.list[index].id3 = data;
        self.forceData[index] = true;
        let leng = Object.keys(self.forceData).length;
        this.forceNotification.updateMessageOnly("TagReader -> " + leng + " / " + self.list.length);
        if (leng === self.list.length) {
            self.forceNotification.remove()
        }
    }
}