/**
* Return sorted top albums based on the average of each album rating.
*
* @param bHideUnmounted if true, unmounted albums are not chosen
* @param iNbBestofAlbums nb of items to return
* @return top albums, can be less items than required according to nb of available albums
*/
public List<Album> getBestOfAlbums(boolean bHideUnmounted, int iNbBestofAlbums) {
// TODO: this code does not look at "bHideUnmounted" at all, so most of this
// method and
// the double copying is not necessary, or?
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> album rates
final Map<Album, Float> cacheRate =
new HashMap<Album, Float>(AlbumManager.getInstance().getElementCount());
ReadOnlyIterator<Album> it = AlbumManager.getInstance().getAlbumsIterator();
while (it.hasNext()) {
Album album = it.next();
cacheRate.put(album, (float) album.getRate());
}
// Now sort albums by rating
List<Album> sortedAlbums = new ArrayList<Album>(cacheRate.keySet());
Collections.sort(
sortedAlbums,
new Comparator<Album>() {
public int compare(Album o1, Album o2) {
// lowest first
return (int) (cacheRate.get(o1) - cacheRate.get(o2));
}
});
return getTopAlbums(sortedAlbums, iNbBestofAlbums);
}
/** @return ItemManager associated with selected element in combo box */
ItemManager getItemManager() {
ItemManager im = null;
switch (jcbItemChoice.getSelectedIndex()) {
case 0:
im = TrackManager.getInstance();
break;
case 1:
im = FileManager.getInstance();
break;
case 2:
im = StyleManager.getInstance();
break;
case 3:
im = AuthorManager.getInstance();
break;
case 4:
im = AlbumManager.getInstance();
break;
case 5:
im = DeviceManager.getInstance();
break;
case 6:
im = DirectoryManager.getInstance();
break;
case 7:
im = PlaylistFileManager.getInstance();
break;
case 8:
im = YearManager.getInstance();
break;
}
return im;
}
/**
* Force to refresh the album max rating, it is not done soon as it is pretty CPU consumming and
* we don't need a track by track rating precision.
*/
public void refreshMaxRating() {
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> album rates
final Map<Album, Float> cacheRate =
new HashMap<Album, Float>(AlbumManager.getInstance().getElementCount());
ReadOnlyIterator<Album> it = AlbumManager.getInstance().getAlbumsIterator();
while (it.hasNext()) {
Album album = it.next();
cacheRate.put(album, (float) album.getRate());
}
// OK, now keep only the highest score
for (Map.Entry<Album, Float> album : cacheRate.entrySet()) {
long value = Math.round(album.getValue());
if (value > maxRate) {
maxRate = value;
}
}
}
/**
* Return ordered rarely listen albums list.
*
* @param bHideUnmounted if true, unmounted albums are not chosen
* @param iNb nb of items to return
* @return top albums, can be less items than required according to nb of available albums
*/
public List<Album> getRarelyListenAlbums(boolean bHideUnmounted, int iNb) {
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> album hits (each track hit average)
final Map<Album, Float> cache =
new HashMap<Album, Float>(AlbumManager.getInstance().getElementCount());
// This hashmap contains album-> nb of tracks already taken into account
// for average
Map<Album, Integer> cacheNb =
new HashMap<Album, Integer>(AlbumManager.getInstance().getElementCount());
ReadOnlyIterator<Track> it = TrackManager.getInstance().getTracksIterator();
while (it.hasNext()) {
Track track = it.next();
if (track.getPlayeableFile(bHideUnmounted) != null) {
float newHits = 0f;
Integer nb = cacheNb.get(track.getAlbum());
if (nb == null) {
nb = 0;
}
Float previousRate = cache.get(track.getAlbum());
if (previousRate == null) {
newHits = track.getHits();
} else {
newHits = ((previousRate * nb) + track.getHits()) / (nb + 1);
}
cacheNb.put(track.getAlbum(), nb + 1);
cache.put(track.getAlbum(), newHits);
}
}
// Now sort albums by rating
List<Album> sortedAlbums = new ArrayList<Album>(cache.keySet());
Collections.sort(
sortedAlbums,
new Comparator<Album>() {
public int compare(Album o1, Album o2) {
// We inverse comparison as we want lowest scores
return (int) (cache.get(o2) - cache.get(o1));
}
});
return getTopAlbums(sortedAlbums, iNb);
}
/**
* Return top albums based on the average of each album rating
*
* @param bHideUnmounted if true, unmounted albums are not chosen
* @param iNbBestofAlbums nb of items to return
* @return top albums, can be less items than required according to nb of available albums
*/
public List<Album> getBestOfAlbums(boolean bHideUnmounted, int iNbBestofAlbums) {
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> album rates
final HashMap<Album, Float> cacheRate =
new HashMap<Album, Float>(AlbumManager.getInstance().getElementCount());
// This hashmap contains album-> nb of tracks already taken into account
// for average
HashMap<Album, Integer> cacheNb =
new HashMap<Album, Integer>(AlbumManager.getInstance().getElementCount());
for (Track track : TrackManager.getInstance().getTracks()) {
if (track.getPlayeableFile(bHideUnmounted) != null) {
float newRate = 0f;
Integer nb = cacheNb.get(track.getAlbum());
if (nb == null) {
nb = 0;
}
Float previousRate = cacheRate.get(track.getAlbum());
if (previousRate == null) {
newRate = track.getRate();
} else {
newRate = ((previousRate * nb) + track.getRate()) / (nb + 1);
}
cacheNb.put(track.getAlbum(), nb + 1);
cacheRate.put(track.getAlbum(), newRate);
}
}
// Now sort albums by rating
ArrayList<Album> sortedAlbums = new ArrayList<Album>(cacheRate.keySet());
Collections.sort(
sortedAlbums,
new Comparator<Album>() {
public int compare(Album o1, Album o2) {
// lowest first
return (int) (cacheRate.get(o1) - cacheRate.get(o2));
}
});
return getTopAlbums(sortedAlbums, iNbBestofAlbums);
}
/**
* Force to refresh the album max rating, it is not done soon as it is pretty CPU consumming and
* we don't need a track by track rating precision
*/
public void refreshMaxRating() {
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> album rates
final HashMap<Album, Float> cacheRate =
new HashMap<Album, Float>(AlbumManager.getInstance().getElementCount());
// This hashmap contains album-> nb of tracks already taken into account
// for average
HashMap<Album, Integer> cacheNb =
new HashMap<Album, Integer>(AlbumManager.getInstance().getElementCount());
for (Track track : TrackManager.getInstance().getTracks()) {
if (track.getPlayeableFile(ConfigurationManager.getBoolean(CONF_OPTIONS_HIDE_UNMOUNTED))
!= null) {
float newRate = 0f;
Integer nb = cacheNb.get(track.getAlbum());
if (nb == null) {
nb = 0;
}
Float previousRate = cacheRate.get(track.getAlbum());
if (previousRate == null) {
newRate = track.getRate();
} else {
newRate = ((previousRate * nb) + track.getRate()) / (nb + 1);
}
cacheNb.put(track.getAlbum(), nb + 1);
cacheRate.put(track.getAlbum(), newRate);
}
}
// OK, now keep only the highest score
for (Album album : cacheRate.keySet()) {
long value = Math.round(cacheRate.get(album));
if (value > maxRate) {
maxRate = value;
}
}
}
/**
* Get albums associated with this item
*
* @param item
* @return
*/
public Set<Album> getAssociatedAlbums(Item item) {
synchronized (AlbumManager.getInstance().getLock()) {
Set<Album> out = new TreeSet<Album>();
// If item is a track, return albums containing this track
if (item instanceof Track) {
// we can return as a track has only one album
if (item != null) {
out.add(((Track) item).getAlbum());
}
} else {
Set<Track> tracks = TrackManager.getInstance().getAssociatedTracks(item);
for (Track track : tracks) {
out.add(track.getAlbum());
}
}
return out;
}
}
/**
* Return newest albums
*
* @param bHideUnmounted if true, unmounted albums are not chosen
* @param iNb nb of items to return
* @return newest albums
*/
public List<Album> getNewestAlbums(boolean bHideUnmounted, int iNb) {
// create a temporary table to remove unmounted albums
// We consider an album as mounted if a least one track is mounted
// This hashmap contains album-> discovery date
final HashMap<Album, Date> cache =
new HashMap<Album, Date>(AlbumManager.getInstance().getElementCount());
for (Track track : TrackManager.getInstance().getTracks()) {
if (track.getPlayeableFile(bHideUnmounted) != null) {
cache.put(track.getAlbum(), track.getAdditionDate());
}
}
// Now sort albums by discovery date
ArrayList<Album> sortedAlbums = new ArrayList<Album>(cache.keySet());
Collections.sort(
sortedAlbums,
new Comparator<Album>() {
public int compare(Album o1, Album o2) {
return cache.get(o1).compareTo(cache.get(o2));
}
});
return getTopAlbums(sortedAlbums, iNb);
}