...

src/main/java/kr/co/swh/lecture/opensource/project/discode/music/jda/AudioPlayerSendHandler.java

@@ -0,0 +1,47 @@
+package kr.co.swh.lecture.opensource.project.discode.music.jda; 
+
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.track.playback.MutableAudioFrame;
+import java.nio.Buffer;
+import net.dv8tion.jda.api.audio.AudioSendHandler;
+
+import java.nio.ByteBuffer;
+
+/**
+ * This is a wrapper around AudioPlayer which makes it behave as an AudioSendHandler for JDA. As JDA calls canProvide
+ * before every call to provide20MsAudio(), we pull the frame in canProvide() and use the frame we already pulled in
+ * provide20MsAudio().
+ */
+public class AudioPlayerSendHandler implements AudioSendHandler {
+	private final AudioPlayer audioPlayer;
+	private final ByteBuffer buffer;
+	private final MutableAudioFrame frame;
+
+	/**
+	 * @param audioPlayer Audio player to wrap.
+	 */
+	public AudioPlayerSendHandler(AudioPlayer audioPlayer) {
+		this.audioPlayer = audioPlayer;
+		this.buffer = ByteBuffer.allocate(1024);
+		this.frame = new MutableAudioFrame();
+		this.frame.setBuffer(buffer);
+	}
+
+	@Override
+	public boolean canProvide() {
+		// returns true if audio was provided
+		return audioPlayer.provide(frame);
+	}
+
+	@Override
+	public ByteBuffer provide20MsAudio() {
+		// flip to make it a read buffer
+		((Buffer) buffer).flip();
+		return buffer;
+	}
+
+	@Override
+	public boolean isOpus() {
+		return true;
+	}
+}

src/main/java/kr/co/swh/lecture/opensource/project/discode/music/jda/GuildMusicManager.java

@@ -0,0 +1,35 @@
+package kr.co.swh.lecture.opensource.project.discode.music.jda; 
+
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayerManager;
+
+/**
+ * Holder for both the player and a track scheduler for one guild.
+ */
+public class GuildMusicManager {
+	/**
+	 * Audio player for the guild.
+	 */
+	public final AudioPlayer player;
+	/**
+	 * Track scheduler for the player.
+	 */
+	public final TrackScheduler scheduler;
+
+	/**
+	 * Creates a player and a track scheduler.
+	 * @param manager Audio player manager to use for creating the player.
+	 */
+	public GuildMusicManager(AudioPlayerManager manager) {
+		player = manager.createPlayer();
+		scheduler = new TrackScheduler(player);
+		player.addListener(scheduler);
+	}
+
+	/**
+	 * @return Wrapper around AudioPlayer to use it as an AudioSendHandler.
+	 */
+	public AudioPlayerSendHandler getSendHandler() {
+		return new AudioPlayerSendHandler(player);
+	}
+}

src/main/java/kr/co/swh/lecture/opensource/project/discode/music/jda/Main.java

@@ -0,0 +1,137 @@
+package kr.co.swh.lecture.opensource.project.discode.music.jda; 
+
+import org.apache.log4j.Logger;
+
+import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayerManager;
+import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager;
+import com.sedmelluq.discord.lavaplayer.source.AudioSourceManagers;
+import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
+import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+
+import kr.co.swh.lecture.opensource.project.discode.music.YoutubeMusicListener;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.VoiceChannel;
+import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import net.dv8tion.jda.api.managers.AudioManager;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static net.dv8tion.jda.api.requests.GatewayIntent.GUILD_MESSAGES;
+import static net.dv8tion.jda.api.requests.GatewayIntent.GUILD_VOICE_STATES;
+
+public class Main extends ListenerAdapter {
+	public static void main(String[] args) throws Exception {
+//		JDABuilder.create(System.getProperty("NjYzMjgzODYxMTUyNTk1OTkz.XhGROw.Ps3JJIKlEXoE1eah_5OKHwViThY"), GUILD_MESSAGES, GUILD_VOICE_STATES)
+//		.addEventListeners(new Main())
+//		.build();
+		 JDA jda = JDABuilder.createDefault("NjYzMjgzODYxMTUyNTk1OTkz.XhGROw.Ps3JJIKlEXoE1eah_5OKHwViThY")
+		            .addEventListeners(new Main())
+		            .build();
+
+		        // optionally block until JDA is ready
+		        jda.awaitReady();
+	}
+
+	private final AudioPlayerManager playerManager;
+	private final Map<Long, GuildMusicManager> musicManagers;
+
+	private Main() {
+		this.musicManagers = new HashMap<>();
+
+		this.playerManager = new DefaultAudioPlayerManager();
+		AudioSourceManagers.registerRemoteSources(playerManager);
+		AudioSourceManagers.registerLocalSource(playerManager);
+	}
+
+	private synchronized GuildMusicManager getGuildAudioPlayer(Guild guild) {
+		long guildId = Long.parseLong(guild.getId());
+		GuildMusicManager musicManager = musicManagers.get(guildId);
+
+		if (musicManager == null) {
+			musicManager = new GuildMusicManager(playerManager);
+			musicManagers.put(guildId, musicManager);
+		}
+
+		guild.getAudioManager().setSendingHandler(musicManager.getSendHandler());
+
+		return musicManager;
+	}
+
+	@Override
+	public void onGuildMessageReceived(GuildMessageReceivedEvent event) {
+		String[] command = event.getMessage().getContentRaw().split(" ", 2);
+
+		if ("~play".equals(command[0]) && command.length == 2) {
+			loadAndPlay(event.getChannel(), command[1]);
+		} else if ("~skip".equals(command[0])) {
+			skipTrack(event.getChannel());
+		}
+
+		super.onGuildMessageReceived(event);
+	}
+
+	private void loadAndPlay(final TextChannel channel, final String trackUrl) {
+		GuildMusicManager musicManager = getGuildAudioPlayer(channel.getGuild());
+
+		playerManager.loadItemOrdered(musicManager, trackUrl, new AudioLoadResultHandler() {
+			@Override
+			public void trackLoaded(AudioTrack track) {
+				channel.sendMessage("Adding to queue " + track.getInfo().title).queue();
+
+				play(channel.getGuild(), musicManager, track);
+			}
+
+			@Override
+			public void playlistLoaded(AudioPlaylist playlist) {
+				AudioTrack firstTrack = playlist.getSelectedTrack();
+
+				if (firstTrack == null) {
+					firstTrack = playlist.getTracks().get(0);
+				}
+
+				channel.sendMessage("Adding to queue " + firstTrack.getInfo().title + " (first track of playlist " + playlist.getName() + ")").queue();
+
+				play(channel.getGuild(), musicManager, firstTrack);
+			}
+
+			@Override
+			public void noMatches() {
+				channel.sendMessage("Nothing found by " + trackUrl).queue();
+			}
+
+			@Override
+			public void loadFailed(FriendlyException exception) {
+				channel.sendMessage("Could not play: " + exception.getMessage()).queue();
+			}
+		});
+	}
+
+	private void play(Guild guild, GuildMusicManager musicManager, AudioTrack track) {
+		connectToFirstVoiceChannel(guild.getAudioManager());
+
+		musicManager.scheduler.queue(track);
+	}
+
+	private void skipTrack(TextChannel channel) {
+		GuildMusicManager musicManager = getGuildAudioPlayer(channel.getGuild());
+		musicManager.scheduler.nextTrack();
+
+		channel.sendMessage("Skipped to next track.").queue();
+	}
+
+	private static void connectToFirstVoiceChannel(AudioManager audioManager) {
+		if (!audioManager.isConnected() && !audioManager.isAttemptingToConnect()) {
+			for (VoiceChannel voiceChannel : audioManager.getGuild().getVoiceChannels()) {
+				audioManager.openAudioConnection(voiceChannel);
+				break;
+			}
+		}
+	}
+}

src/main/java/kr/co/swh/lecture/opensource/project/discode/music/jda/TrackScheduler.java

@@ -0,0 +1,56 @@
+package kr.co.swh.lecture.opensource.project.discode.music.jda; 
+
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.player.event.AudioEventAdapter;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrackEndReason;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * This class schedules tracks for the audio player. It contains the queue of tracks.
+ */
+public class TrackScheduler extends AudioEventAdapter {
+	private final AudioPlayer player;
+	private final BlockingQueue<AudioTrack> queue;
+
+	/**
+	 * @param player The audio player this scheduler uses
+	 */
+	public TrackScheduler(AudioPlayer player) {
+		this.player = player;
+		this.queue = new LinkedBlockingQueue<>();
+	}
+
+	/**
+	 * Add the next track to queue or play right away if nothing is in the queue.
+	 *
+	 * @param track The track to play or add to queue.
+	 */
+	public void queue(AudioTrack track) {
+		// Calling startTrack with the noInterrupt set to true will start the track only if nothing is currently playing. If
+		// something is playing, it returns false and does nothing. In that case the player was already playing so this
+		// track goes to the queue instead.
+		if (!player.startTrack(track, true)) {
+			queue.offer(track);
+		}
+	}
+
+	/**
+	 * Start the next track, stopping the current one if it is playing.
+	 */
+	public void nextTrack() {
+		// Start the next track, regardless of if something is already playing or not. In case queue was empty, we are
+		// giving null to startTrack, which is a valid argument and will simply stop the player.
+		player.startTrack(queue.poll(), false);
+	}
+
+	@Override
+	public void onTrackEnd(AudioPlayer player, AudioTrack track, AudioTrackEndReason endReason) {
+		// Only start the next track if the end reason is suitable for it (FINISHED or LOAD_FAILED)
+		if (endReason.mayStartNext) {
+			nextTrack();
+		}
+	}
+}