src/com/cooliris/media/MediaBucketList.java

   1 package com.cooliris.media;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5
   6
   7 public final class MediaBucketList {
   8     private static final Boolean TRUE = new Boolean(true);
   9     private static final Boolean FALSE = new Boolean(false);
  10
  11     private ArrayList<MediaBucket> mBuckets = new ArrayList<MediaBucket>(1024);
  12     private boolean mDirtyCount;
  13     private boolean mDirtyAcceleratedLookup;
  14     private int mCount;
  15     private HashMap<MediaItem, Boolean> mCachedItems = new HashMap<MediaItem, Boolean>(1024);
  16
  17     // If only albums are selected, a bucket contains mediaSets.
  18     // If items are selected, a bucket contains mediaSets and mediaItems.
  19
  20     // Returns the first item selection (ignoring items within set selections).
  21     public static MediaItem getFirstItemSelection(ArrayList<MediaBucket> buckets) {
  22         MediaItem item = null;
  23         if (buckets != null) {
  24             int numBuckets = buckets.size();
  25             for (int i = 0; i < numBuckets; i++) {
  26                 MediaBucket bucket = buckets.get(0);
  27                 if (bucket != null && !isSetSelection(bucket)) {
  28                     ArrayList<MediaItem> items = bucket.mediaItems;
  29                     if (items != null && items.size() > 0) {
  30                         item = items.get(0);
  31                         break;
  32                     }
  33                 }
  34             }
  35         }
  36         return item;
  37     }
  38
  39     // Returns the first set selection (ignoring sets corresponding to item selections).
  40     public static MediaSet getFirstSetSelection(ArrayList<MediaBucket> buckets) {
  41         MediaSet set = null;
  42         if (buckets != null) {
  43             int numBuckets = buckets.size();
  44             for (int i = 0; i < numBuckets; i++) {
  45                 MediaBucket bucket = buckets.get(0);
  46                 if (bucket != null && isSetSelection(bucket)) {
  47                     set = bucket.mediaSet;
  48                 }
  49             }
  50         }
  51         return set;
  52     }
  53
  54     public ArrayList<MediaBucket> get() {
  55         return mBuckets;
  56     }
  57
  58     public int size() {
  59         if (mDirtyCount) {
  60             ArrayList<MediaBucket> buckets = mBuckets;
  61             int numBuckets = buckets.size();
  62             int count = 0;
  63             for (int i = 0; i < numBuckets; ++i) {
  64                 MediaBucket bucket = buckets.get(i);
  65                 int numItems = 0;
  66                 if (bucket.mediaItems == null && bucket.mediaSet != null) {
  67                     numItems = bucket.mediaSet.getNumItems();
  68                     // This selection reflects the bucket itself, and not the items inside the bucket (which is 0).
  69                     if (numItems == 0) {
  70                         numItems = 1;
  71                     }
  72                 } else if (bucket.mediaItems != null && bucket.mediaItems != null) {
  73                     numItems = bucket.mediaItems.size();
  74                 }
  75                 count += numItems;
  76             }
  77             mCount = count;
  78             mDirtyCount = false;
  79         }
  80         return mCount;
  81     }
  82
  83     public void add(int slotId, MediaFeed feed, boolean removeIfAlreadyAdded) {
  84         if (slotId == Shared.INVALID) {
  85             return;
  86         }
  87         setDirty();
  88         final ArrayList<MediaBucket> selectedBuckets = mBuckets;
  89         final int numSelectedBuckets = selectedBuckets.size();
  90         MediaSet mediaSetToAdd = null;
  91         ArrayList<MediaItem> selectedItems = null;
  92         MediaBucket bucket = null;
  93         final boolean hasExpandedMediaSet = feed.hasExpandedMediaSet();
  94         if (!hasExpandedMediaSet) {
  95             ArrayList<MediaSet> mediaSets = feed.getMediaSets();
  96             if (slotId >= mediaSets.size()) {
  97                 return;
  98             }
  99             mediaSetToAdd = mediaSets.get(slotId);
 100         } else {
 101             int numSlots = feed.getNumSlots();
 102             if (slotId < numSlots) {
 103                 MediaSet set = feed.getSetForSlot(slotId);
 104                 if (set != null) {
 105                     ArrayList<MediaItem> items = set.getItems();
 106                     if (set.getNumItems() > 0) {
 107                         mediaSetToAdd = items.get(0).mParentMediaSet;
 108                     }
 109                 }
 110             }
 111         }
 112
 113         // Search for the bucket for this media set
 114         for (int i = 0; i < numSelectedBuckets; ++i) {
 115             final MediaBucket bucketCompare = selectedBuckets.get(i);
 116             if (bucketCompare.mediaSet == mediaSetToAdd) {
 117                 // We found the MediaSet.
 118                 if (!hasExpandedMediaSet) {
 119                     // Remove this bucket from the list since this bucket was already selected.
 120                     if (removeIfAlreadyAdded) {
 121                         selectedBuckets.remove(bucketCompare);
 122                     }
 123                     return;
 124                 } else {
 125                     bucket = bucketCompare;
 126                     break;
 127                 }
 128             }
 129         }
 130         if (bucket == null) {
 131             // Did not find the media bucket.
 132             bucket = new MediaBucket();
 133             bucket.mediaSet = mediaSetToAdd;
 134             bucket.mediaItems = selectedItems;
 135             selectedBuckets.add(bucket);
 136         }
 137         if (hasExpandedMediaSet) {
 138             int numSlots = feed.getNumSlots();
 139             if (slotId < numSlots) {
 140                 MediaSet set = feed.getSetForSlot(slotId);
 141                 if (set != null) {
 142                     ArrayList<MediaItem> items = set.getItems();
 143                     int numItems = set.getNumItems();
 144                     selectedItems = bucket.mediaItems;
 145                     if (selectedItems == null) {
 146                         selectedItems = new ArrayList<MediaItem>(numItems);
 147                         bucket.mediaItems = selectedItems;
 148                     }
 149                     for (int i = 0; i < numItems; ++i) {
 150                         MediaItem item = items.get(i);
 151                         // We see if this item has already been added.
 152                         int numPresentItems = selectedItems.size();
 153                         boolean foundIndex = false;
 154                         for (int j = 0; j < numPresentItems; ++j) {
 155                             if (selectedItems.get(j) == item) {
 156                                 // This index was already present, we need to remove it.
 157                                 foundIndex = true;
 158                                 if (removeIfAlreadyAdded) {
 159                                     selectedItems.remove(j);
 160                                 }
 161                                 break;
 162                             }
 163                         }
 164                         if (foundIndex == false) {
 165                             selectedItems.add(item);
 166                         }
 167                     }
 168                 }
 169             }
 170         }
 171         setDirty();
 172     }
 173
 174     public boolean find(MediaItem item) {
 175         HashMap<MediaItem, Boolean> cachedItems = mCachedItems;
 176         if (mDirtyAcceleratedLookup) {
 177             cachedItems.clear();
 178             mDirtyAcceleratedLookup = false;
 179         }
 180         Boolean itemAdded = cachedItems.get(item);
 181         if (itemAdded == null) {
 182             ArrayList<MediaBucket> selectedBuckets = mBuckets;
 183             int numSelectedBuckets = selectedBuckets.size();
 184             for (int i = 0; i < numSelectedBuckets; ++i) {
 185                 MediaBucket bucket = selectedBuckets.get(i);
 186                 ArrayList<MediaItem> mediaItems = bucket.mediaItems;
 187                 if (mediaItems == null) {
 188                     MediaSet parentMediaSet = item.mParentMediaSet;
 189                     if (parentMediaSet != null && parentMediaSet.equals(bucket.mediaSet)) {
 190                         cachedItems.put(item, TRUE);
 191                         return true;
 192                     }
 193                 } else {
 194                     int numMediaItems = mediaItems.size();
 195                     for (int j = 0; j < numMediaItems; ++j) {
 196                         MediaItem itemCompare = mediaItems.get(j);
 197                         if (itemCompare == item) {
 198                             cachedItems.put(item, TRUE);
 199                             return true;
 200                         }
 201                     }
 202                 }
 203             }
 204             cachedItems.put(item, FALSE);
 205             return false;
 206         } else {
 207             return itemAdded.booleanValue();
 208         }
 209     }
 210
 211     public void clear() {
 212         mBuckets.clear();
 213         setDirty();
 214     }
 215
 216     private void setDirty() {
 217         mDirtyCount = true;
 218         mDirtyAcceleratedLookup = true;
 219     }
 220
 221     // Assumption: No item and set selection combinations.
 222     protected static boolean isSetSelection(ArrayList<MediaBucket> buckets) {
 223         if (buckets != null) {
 224             int numBuckets = buckets.size();
 225             if (numBuckets == 0) {
 226                 return false;
 227             } else if (numBuckets == 1) {
 228                 return isSetSelection(buckets.get(0));
 229             } else {
 230                 // If there are multiple sets, must be a set selection.
 231                 return true;
 232             }
 233         }
 234         return false;
 235     }
 236
 237     protected static boolean isSetSelection(MediaBucket bucket) {
 238         return (bucket.mediaSet != null && bucket.mediaItems == null) ? true : false;
 239     }
 240
 241     // Assumption: If multiple items are selected, they must all be in the first bucket.
 242     protected static boolean isMultipleItemSelection(ArrayList<MediaBucket> buckets) {
 243         if (buckets != null) {
 244             int numBuckets = buckets.size();
 245             if (numBuckets == 0) {
 246                 return false;
 247             } else {
 248                 return isMultipleSetSelection(buckets.get(0));
 249             }
 250         }
 251         return false;
 252     }
 253
 254     protected static boolean isMultipleSetSelection(MediaBucket bucket) {
 255         return (bucket.mediaItems != null && bucket.mediaItems.size() > 1) ? true : false;
 256     }
 257 }