path: root/native-app/index.js

#!/usr/bin/env node

const { promisify } = require('util');
const { spawn } = require('child_process');
const EventEmitter = require('events');
const FIFO = require('fifo-js');
const http = require('http');
const path = require('path');
const fs = require('fs');
const os = require('os');
const sanitizeFilename = require('sanitize-filename');

const readdir = promisify(fs.readdir);

const basePath = path.resolve(__dirname, '..');
const logFile = basePath + '/native-app/log';
const log = msg => fs.appendFileSync(logFile, msg + '\n');
// const log = () => {};

log('Started ' + Date());

const emptyStream = () => {
    const stream = new EventEmitter();
    stream.write = () => {};
    stream.end = () => {};
    return stream;
};

class TrackPlayer {
    constructor(file) {
        this.file = file;
        this.volume = 0;
        this.storedVolume = this.volume;
        log('Created track: ' + file);
    }

    loadProcess() {
        this.fifo = new FIFO();
        this.process = spawn('mpv', [
            '--no-video',
            '--loop',
            '--volume=' + this.volume,
            '--input-file=' + this.fifo.path,
            this.file,
        ]);

        this.process.stderr.pipe(emptyStream());
    }

    sendCommand(command) {
        if (this.fifo) {
            this.fifo.write(command);
        }
    }

    seekToStart() {
        this.sendCommand('seek 0 absolute');
    }

    pause() {
        this.sendCommand('set pause yes');
    }

    play() {
        this.sendCommand('set pause no');
    }

    setVolume(volume) {
        if (Math.floor(volume) !== this.storedVolume) {
            this.storedVolume = Math.floor(volume);
            this.sendCommand(`set volume ${volume}`);
        }
        this.volume = volume;
    }
}

const musicDir = basePath + '/native-app/music';

let tracks;

const loadTracks = () => new Promise(async resolve => {
    tracks = {};

    for (const trackName of await readdir(musicDir)) {
        tracks[trackName] = new TrackPlayer(musicDir + '/' + trackName);
    }

    for (const track of Object.values(tracks)) {
        track.loadProcess();
        track.pause();
    }

    setTimeout(() => {
        for (const track of Object.values(tracks)) {
            track.seekToStart();
            track.play();
        }

        resolve();
    }, 250);
});

const killTracks = () => {
    for (const track of Object.values(tracks)) {
        track.process.kill();
    }
};

loadTracks().then(async () => {
    let targetMode = [
        {track: 'main', volume: 100}
    ];

    setInterval(() => {
        if (!Array.isArray(targetMode)) {
            targetMode = [];
        }

        for (const [key, track] of Object.entries(tracks)) {
            const mode = targetMode.find(m => m.track === key) || {volume: 0};
            track.setVolume(track.volume + 0.02 * (mode.volume - track.volume));
        }
    }, 20);

    const uploadData = {};

    const handleCommand = text => {
        log('COMMAND: ' + text);

        const probablyJSON = text.slice(Math.min(...[
            text.indexOf('['), text.indexOf('{')
        ].filter(x => x >= 0))).trim();

        let data;

        try {
            data = JSON.parse(probablyJSON);
        } catch (error) {
            return;
        }

        if (Array.isArray(data)) {
            targetMode = data;
        } else if (data.type === 'uploadTrack') {
            const buffer = Buffer.from(data.base64, 'base64');
            log(`Write file: ${data.trackName} -- ${buffer.length} bytes`);
            fs.writeFileSync(musicDir + '/' + sanitizeFilename(data.trackName), buffer);
            killTracks();
            loadTracks();
            writeMessage(JSON.stringify({type: 'uploadFinished', trackName: data.trackName}));
        } else if (data.type === 'deleteTrack') {
            try {
                fs.unlinkSync(musicDir + '/' + sanitizeFilename(data.trackName));
            } catch (error) {
                log('Error deleting track: ' + error);
            }

            if (tracks[data.trackName]) {
                tracks[data.trackName].process.kill();
                delete tracks[data.trackName];
            }

            writeMessage(JSON.stringify({type: 'deleteFinished', trackName: data.trackName}));
        }
    };

    let readBytesPromise = null;
    let stdinBuffer = Buffer.from([]);

    process.stdin.on('data', data => {
        stdinBuffer = Buffer.concat([stdinBuffer, data]);
        if (readBytesPromise) {
            readBytesPromise();
        }
    });

    const readBytes = numBytes => {
        if (stdinBuffer.length >= numBytes) {
            const bytes = stdinBuffer.slice(0, numBytes);
            stdinBuffer = stdinBuffer.slice(numBytes); // Splice
            return Promise.resolve(bytes);
        } else {
            return new Promise(resolve => {
                readBytesCount = numBytes;
                readBytesPromise = resolve;
            }).then(() => readBytes(numBytes));
        }
    };

    const writeMessage = message => {
        log(message);

        const size = message.length;
        const rawSize = Buffer.alloc(4);
        if (os.endianness() === 'BE') {
            rawSize.writeUInt32BE(size, 0);
        } else {
            rawSize.writeUInt32LE(size, 0);
        }

        process.stdout.write(rawSize);
        process.stdout.write(Buffer.from(message, 'utf8'));
    };

    while (true) {
        const rawSize = await readBytes(4);
        let size;
        if (os.endianness() === 'BE') {
            size = rawSize.readUInt32BE();
        } else {
            size = rawSize.readUInt32LE();
        }
        const data = await readBytes(size);
        const command = data.toString('utf8');
        handleCommand(command);
    }
});

log('Go!');

process.on('SIGTERM', () => {
    log('Exiting');
    killTracks();
    log('Cleaned up');
});