MemphisDJ/src/music/Library.java

   1
   2 package music;
   3
   4 import interfaces.Album;
   5 import interfaces.Track;
   6 import interfaces.collection.AbstractCollection;
   7 import interfaces.collection.AbstractSetSource;
   8 import interfaces.collection.Collection;
   9 import interfaces.collection.Source;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashSet;
  13 import java.util.Iterator;
  14 import java.util.List;
  15 import java.util.Set;
  16
  17 import javax.imageio.spi.ServiceRegistry;
  18
  19 import spi.SourceProvider;
  20
  21 import notification.AbstractEventGenerator;
  22 import notification.LibraryListener;
  23
  24 public class Library extends AbstractSetSource<LibraryTrack>
  25                 implements Source.Listener, interfaces.Library<LibraryTrack> {
  26
  27         private final Set<Source<? extends Track>> sources = new HashSet<Source<? extends Track>>();
  28         private final Set<Collection<? extends Track>> collections = new HashSet<Collection<? extends Track>>();
  29         private final Set<SourceProvider> providers = new HashSet<SourceProvider>();
  30
  31         private volatile int nextCollection = Collection.FIRST_AVAILABLE_ID;
  32
  33         public Library(String name) {
  34                 super();
  35                 this.name = name;
  36                 this.lib = this;
  37
  38                 addCollection(this.collection()); //library is a collection in the library
  39                 monitor.nextVersion();
  40
  41                 for (Iterator<SourceProvider> it = ServiceRegistry.lookupProviders(SourceProvider.class); it.hasNext();) {
  42                         SourceProvider provider = it.next();
  43                         System.out.println("using source provider: " + provider.getClass().getName());
  44                         provider.create(this);
  45                         providers.add(provider);
  46                 }
  47         }
  48
  49         private final String name;
  50         private final Library lib;
  51         private final Collection<LibraryTrack> collection = new AbstractCollection<LibraryTrack>(Collection.LIBRARY_ID, Collection.LIBRARY_PERSISTENT_ID) {
  52
  53                 public int editStatus() {
  54                         return Collection.NOT_EDITABLE;
  55                 }
  56
  57                 public boolean isRoot() {
  58                         return true;
  59                 }
  60
  61                 public String name() {
  62                         return name;
  63                 }
  64
  65                 public Collection<? extends LibraryTrack> parent() {
  66                         return null;
  67                 }
  68
  69                 public int size() {
  70                         return lib.size();
  71                 }
  72
  73                 public Source<LibraryTrack> source() {
  74                         return lib;
  75                 }
  76         };
  77
  78         public Collection<LibraryTrack> collection() {
  79                 return collection;
  80         }
  81
  82         public boolean addSource(Source<? extends Track> source) {
  83                 if (sources.add(source)) {
  84                         added(source.tracks());
  85                         source.registerListener(this);
  86                         return true;
  87                 }
  88                 return false;
  89         }
  90
  91         public boolean removeSource(Source<? extends Track> source) {
  92                 if (sources.remove(source)) {
  93                         source.removeListener(this);
  94                         Set<Track> trackSet = new HashSet<Track>();
  95                         for (Track t: source.tracks()) {
  96                                 trackSet.add(t);
  97                         }
  98                         removed(trackSet);
  99                         return true;
 100                 }
 101                 return false;
 102         }
 103
 104         public void added(Iterable<? extends Track> tracks) {
 105
 106                 List<LibraryTrack> added = new ArrayList<LibraryTrack>();
 107
 108                 for (Track t: tracks) {
 109                         LibraryTrack l = LibraryTrack.factory().create(t);
 110                         l.addBackingTrack(t);
 111                         added.add(l);
 112                 }
 113
 114                 add(added);
 115                 monitor.nextVersion();
 116         }
 117
 118         public void removed(Set<? extends Track> tracks) {
 119
 120                 Set<LibraryTrack> removed = new HashSet<LibraryTrack>();
 121
 122                 for (Track t: tracks) {
 123                         LibraryTrack l = LibraryTrack.factory().create(t);
 124                         if (store.contains(l)) {
 125                                 l.removeBackingTrack(t);
 126                                 if (l.numBackingTracks() == 0) {
 127                                         removed.add(l);
 128                                 }
 129                         }
 130                 }
 131
 132                 remove(removed);
 133                 monitor.nextVersion();
 134         }
 135
 136         public synchronized int nextCollectionId() {
 137                 return nextCollection++;
 138         }
 139
 140         public boolean addCollection(Collection<? extends Track> collection) {
 141                 boolean added = collections.add(collection);
 142                 if (added) {
 143                         monitor.nextVersion();
 144                 }
 145                 return added;
 146         }
 147
 148         public Iterable<Collection<? extends Track>> collections() {
 149                 return collections;
 150         }
 151
 152         public int numCollections() {
 153                 return collections.size();
 154         }
 155
 156         public boolean removeCollection(Collection<? extends Track> collection) {
 157                 boolean removed = collections.remove(collection);
 158                 if (removed) {
 159                         monitor.nextVersion();
 160                 }
 161                 return removed;
 162         }
 163
 164         public Iterable<? extends Album> albums() {
 165
 166                 Set<Album> albums = new HashSet<Album>();
 167                 for (Track t: tracks()) {
 168                         albums.add(t.getAlbum());
 169                 }
 170                 return albums;
 171         }
 172
 173         public int numAlbums() {
 174                 Set<Album> albums = new HashSet<Album>();
 175                 for (Track t: tracks()) {
 176                         albums.add(t.getAlbum());
 177                 }
 178                 return albums.size();
 179         }
 180
 181         public void registerLibraryListener(LibraryListener listener) {
 182                 monitor.registerListener(listener);
 183         }
 184
 185         public void removeLibraryListener(LibraryListener listener) {
 186                 monitor.removeListener(listener);
 187         }
 188
 189         public int version() {
 190                 return monitor.version();
 191         }
 192
 193         public void connect(String path) {
 194
 195                 for (SourceProvider provider: providers) {
 196                         provider.connect(path);
 197                 }
 198
 199         }
 200
 201         private LibraryMonitor monitor = new LibraryMonitor();
 202         private class LibraryMonitor extends AbstractEventGenerator<LibraryListener> {
 203                 private int version;
 204                 public synchronized int version() {
 205                         return version;
 206                 }
 207                 public synchronized void nextVersion() {
 208                         version++;
 209                         for (LibraryListener l: listeners()) {
 210                                 l.libraryVersionChanged(version);
 211                         }
 212                 }
 213         }
 214 }