Sets the main package name to universeplayer.

The extra underscore was causing problems with the JNI.

interface/src/main/java/edu/regis/universeplayer/data/SimpleSongProvider.java

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2021 William Hubbard. All Rights Reserved.
+ */
+
+package edu.regis.universeplayer.data;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+/**
+ * A test song database that automatically generates a handful of songs.
+ *
+ * @author William Hubbard
+ * @version 0.1
+ */
+public class SimpleSongProvider implements SongProvider
+{
+    private ArrayList<Album> albums;
+    private ArrayList<Song> songs;
+
+    @Override
+    public Collection<Album> getAlbums()
+    {
+        if (albums == null)
+        {
+            albums = new ArrayList<>();
+            Random random = new Random();
+            StringBuilder builder;
+            String albumName, albumArtist;
+            Album album;
+            for (int albumNum = 0, numAlbums = random
+                    .nextInt(20) + 20; albumNum < numAlbums; albumNum++)
+            {
+                builder = new StringBuilder();
+                for (int i = 0, l = random.nextInt(10) + 10; i < l; i++)
+                {
+                    builder.append((char) (random.nextInt(26) + 97));
+                }
+                albumName = builder.toString();
+
+                builder = new StringBuilder();
+                for (int i = 0, l = random.nextInt(10) + 10; i < l; i++)
+                {
+                    builder.append((char) (random.nextInt(26) + 97));
+                }
+                albumArtist = builder.toString();
+
+                album = new Album()
+                {
+                };
+
+                album.name = albumName;
+                album.artists = new String[]{albumArtist};
+                album.genres = new String[]{"Soundtrack"};
+                album.year = 2019;
+                album.totalTracks = random.nextInt(10) + 10;
+                album.id = albumNum;
+
+                albums.add(album);
+            }
+        }
+
+        return albums;
+    }
+
+    @Override
+    public Collection<Song> getSongs()
+    {
+        if (songs == null)
+        {
+            /*
+             * Generate a list of songs
+             */
+            Random random = new Random();
+            StringBuilder builder;
+            String songTitle;
+            Song song;
+            int songNum, numSongs;
+            songs = new ArrayList<>();
+            for (Album album : this.getAlbums())
+            {
+                for (songNum = 0, numSongs = album.totalTracks; songNum < numSongs; songNum++)
+                {
+                    builder = new StringBuilder();
+                    for (int i = 0, l = random.nextInt(10) + 10; i < l; i++)
+                    {
+                        builder.append((char) (random.nextInt(26) + 97));
+                    }
+                    songTitle = builder.toString();
+
+                    song = new Song()
+                    {
+                    };
+                    song.title = songTitle;
+                    song.disc = 1;
+                    song.trackNum = songNum + 1;
+                    song.artists = album.artists.clone();
+                    song.album = album;
+                    songs.add(song);
+                }
+                album.totalTracks = numSongs;
+            }
+        }
+        return this.songs;
+    }
+
+    @Override
+    public Collection<String> getArtists()
+    {
+        return this.songs.stream().flatMap(song -> Arrays.stream(song.artists)).sorted()
+                         .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<String> getGenres()
+    {
+        return this.songs.stream().flatMap(song -> Arrays.stream(song.album.genres)).sorted()
+                         .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<String> getAlbumArtists()
+    {
+        return this.albums.stream().flatMap(album -> Arrays.stream(album.artists)).sorted()
+                          .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Integer> getYears()
+    {
+        return this.albums.stream().map(album -> album.year).sorted()
+                          .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Song> getSongsFromAlbum(Album album)
+    {
+        return this.songs.stream().filter(song -> song.album == album).sorted()
+                         .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Song> getSongsFromArtist(String artist)
+    {
+        return this.songs.stream().filter(song -> Arrays.asList(song.artists).contains(artist)).sorted()
+                         .collect(Collectors.toList());
+    }
+
+    @Override
+    public Album getAlbumByName(String name)
+    {
+        return this.albums.stream().filter(album -> album.name.equals(name)).findFirst().orElse(null);
+    }
+
+    @Override
+    public Collection<Album> getAlbumsFromArtist(String artist)
+    {
+        return this.albums.stream().filter(album -> Arrays.asList(album.artists).contains(artist))
+                          .sorted().collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Album> getAlbumsFromGenre(String genre)
+    {
+        return this.albums.stream().filter(album -> Arrays.asList(album.genres).contains(genre))
+                          .sorted().collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Album> getAlbumsFromYear(int year)
+    {
+        return this.albums.stream().filter(album -> album.year == year)
+                          .sorted().collect(Collectors.toList());
+    }
+}