Merge pull request #2 from markusgod/instantReplay

Instant replay

Author: Mark Nefedov

.gitignore

@@ -15,4 +15,8 @@ gradle-app.setting
 
 # IDE
 .idea/
-*.iml
+*.iml
+
+#created by bot
+temp/
+records/

README.md

@@ -1,11 +1,16 @@
 # Simple Discord bot in Kotlin
 A simple bot for recording voice chats.
 
-Usage:
+For simple recording:
 ```
 ::record time
 ::stop
 ```
+"Instant replay" functions much like Nvidia's ShadowPlay instant replays (that is where name come from). Bot is constantly recording audio from a channel to a buffer and will send current buffer content in a file when you request it.
+```
+:!record 
+:!replay
+```
 
 After recording bot will send an audio file to the chat it was started from.
 

build.gradle

@@ -13,6 +13,8 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     compile "net.dv8tion:JDA:4.1.1_101"
     compile group: 'ws.schild', name: 'jave-all-deps', version: '2.7.3'
+    compile group: 'org.apache.commons', name: 'commons-collections4', version: '4.4'
+    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
 }
 
 compileKotlin {

src/main/kotlin/FileEncoder.kt

@@ -0,0 +1,44 @@
+import net.dv8tion.jda.api.audio.AudioReceiveHandler
+import ws.schild.jave.AudioAttributes
+import ws.schild.jave.Encoder
+import ws.schild.jave.EncodingAttributes
+import ws.schild.jave.MultimediaObject
+import java.io.ByteArrayInputStream
+import java.io.File
+import javax.sound.sampled.AudioFileFormat
+import javax.sound.sampled.AudioInputStream
+import javax.sound.sampled.AudioSystem
+
+const val tempFolder = "temp"
+
+fun createWAVFile(buffer: Array<Byte>, filename: String): File {
+    val directory = File(tempFolder)
+    if (!directory.exists())
+        directory.mkdir()
+
+    val audioStream = AudioInputStream(
+        ByteArrayInputStream(buffer.toByteArray()),
+        AudioReceiveHandler.OUTPUT_FORMAT,
+        buffer.size.toLong()
+    )
+    val wav = File("$tempFolder/$filename.wav")
+    AudioSystem.write(audioStream, AudioFileFormat.Type.WAVE, wav)
+    return wav
+}
+
+fun convertToMP3(file: File): File {
+    val encoder = Encoder()
+    val audioAttributes = AudioAttributes().apply {
+        setCodec("libmp3lame")
+        setBitRate(48000)
+        setChannels(1)
+        setSamplingRate(44100)
+    }
+    val attrs = EncodingAttributes().apply {
+        format = "mp3"
+        setAudioAttributes(audioAttributes)
+    }
+    val mp3 = File("$tempFolder/${file.name}.mp3")
+    encoder.encode(MultimediaObject(file), mp3, attrs)
+    return mp3
+}

src/main/kotlin/InstantReplayCommandHandler.kt

@@ -0,0 +1,58 @@
+import net.dv8tion.jda.api.audio.AudioReceiveHandler
+import net.dv8tion.jda.api.audio.CombinedAudio
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceLeaveEvent
+import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent
+import net.dv8tion.jda.api.hooks.ListenerAdapter
+import org.apache.commons.collections4.queue.CircularFifoQueue
+import java.time.LocalDateTime
+
+const val bufferSize = 50000000
+
+class InstantReplayCommandHandler : ListenerAdapter() {
+    override fun onGuildMessageReceived(event: GuildMessageReceivedEvent) {
+        super.onGuildMessageReceived(event)
+        if (event.message.contentRaw.startsWith(":!record") && event.member?.voiceState?.inVoiceChannel() == true) {
+            if (event.guild.audioManager.receivingHandler == null) {
+                event.guild.audioManager.receivingHandler = InstantReplayAudioHandler()
+            }
+            event.guild.audioManager.openAudioConnection(event.member?.voiceState?.channel)
+        }
+
+        if (event.message.contentRaw.startsWith(":!replay")) {
+            val replayAudioHandler = event.guild.audioManager.receivingHandler as? InstantReplayAudioHandler ?: return
+            val wavRecord = createWAVFile(
+                replayAudioHandler.getRecordBytes().toTypedArray().copyOf(),
+                "${LocalDateTime.now()}${event.guild.id}"
+            )
+            val mp3Compressed = convertToMP3(wavRecord)
+            wavRecord.delete()
+            event.message.textChannel.sendFile(mp3Compressed).submit().thenRunAsync { mp3Compressed.delete() }
+        }
+    }
+
+    override fun onGuildVoiceLeave(event: GuildVoiceLeaveEvent) {
+        super.onGuildVoiceLeave(event)
+        if (event.member.id == clientId)
+        {
+            println("Bot leave from: ${event.channelLeft.name}")
+            event.guild.audioManager.receivingHandler = null
+        }
+    }
+}
+
+class InstantReplayAudioHandler : AudioReceiveHandler {
+    private var buffer = CircularFifoQueue<Byte>(bufferSize)
+    override fun canReceiveCombined(): Boolean {
+        return true
+    }
+
+    override fun handleCombinedAudio(combinedAudio: CombinedAudio) {
+        super.handleCombinedAudio(combinedAudio)
+        val decodedData = combinedAudio.getAudioData(1.0)
+        buffer.addAll(decodedData.toTypedArray())
+    }
+
+    fun getRecordBytes(): Collection<Byte> {
+        return buffer
+    }
+}

src/main/kotlin/main.kt

@@ -1,16 +1,33 @@
 import net.dv8tion.jda.api.JDABuilder
 
+lateinit var clientId : String
+
 fun main(args : Array<String>) {
     val token = when {
         args.isNotEmpty() -> args[0]
         System.getenv("BOT_TOKEN") != null -> System.getenv("BOT_TOKEN")
         else -> {
-            print("Bot token:")
+            println("Bot token:")
             (readLine() ?: return)
         }
     }
+
+    clientId = when {
+        args.size > 1 -> args[1]
+        System.getenv("CLIENT_ID") != null -> System.getenv("CLIENT_ID")
+        else -> {
+            println("Client id: ")
+            (readLine() ?: return)
+        }
+    }
+
+    println("Starting bot")
     JDABuilder(token).apply {
-        addEventListeners(RecordCommandHandler())
+        addEventListeners(
+            RecordCommandHandler(),
+            InstantReplayCommandHandler()
+        )
+        setAutoReconnect(true)
         build()
     }
 }