package com.cooliris.media;
import java.util.ArrayList;
import java.util.HashMap;
import android.content.Context;
import android.view.Gravity;
import android.widget.Toast;
import android.os.Process;
import com.cooliris.media.MediaClustering.Cluster;
public final class MediaFeed implements Runnable {
public static final int OPERATION_DELETE = 0;
public static final int OPERATION_ROTATE = 1;
public static final int OPERATION_CROP = 2;
private static final int NUM_ITEMS_LOOKAHEAD = 60;
private IndexRange mVisibleRange = new IndexRange();
private IndexRange mBufferedRange = new IndexRange();
private ArrayList<MediaSet> mMediaSets = new ArrayList<MediaSet>();
private Listener mListener;
private DataSource mDataSource;
private boolean mListenerNeedsUpdate = false;
private boolean mMediaFeedNeedsToRun = false;
private MediaSet mSingleWrapper = new MediaSet();
private boolean mInClusteringMode = false;
private HashMap<MediaSet, MediaClustering> mClusterSets = new HashMap<MediaSet, MediaClustering>(32);
private int mExpandedMediaSetIndex = Shared.INVALID;
private MediaFilter mMediaFilter;
private MediaSet mMediaFilteredSet;
private Context mContext;
private Thread mDataSourceThread = null;
private Thread mAlbumSourceThread = null;
private boolean mListenerNeedsLayout;
private boolean mWaitingForMediaScanner;
private boolean mSingleImageMode;
private boolean mLoading;
public interface Listener {
public abstract void onFeedAboutToChange(MediaFeed feed);
public abstract void onFeedChanged(MediaFeed feed, boolean needsLayout);
}
public MediaFeed(Context context, DataSource dataSource, Listener listener) {
mContext = context;
mListener = listener;
mDataSource = dataSource;
mSingleWrapper.setNumExpectedItems(1);
mLoading = true;
}
public void shutdown() {
if (mDataSourceThread != null) {
mDataSource.shutdown();
mDataSourceThread.interrupt();
mDataSourceThread = null;
}
if (mAlbumSourceThread != null) {
mAlbumSourceThread.interrupt();
mAlbumSourceThread = null;
}
int numSets = mMediaSets.size();
for (int i = 0; i < numSets; ++i) {
MediaSet set = mMediaSets.get(i);
set.clear();
}
synchronized (mMediaSets) {
mMediaSets.clear();
}
int numClusters = mClusterSets.size();
for (int i = 0; i < numClusters; ++i) {
MediaClustering mc = mClusterSets.get(i);
if (mc != null) {
mc.clear();
}
}
mClusterSets.clear();
mListener = null;
mDataSource = null;
mSingleWrapper = null;
}
public void setVisibleRange(int begin, int end) {
if (begin != mVisibleRange.begin || end != mVisibleRange.end) {
mVisibleRange.begin = begin;
mVisibleRange.end = end;
int numItems = 96;
int numItemsBy2 = numItems / 2;
int numItemsBy4 = numItems / 4;
mBufferedRange.begin = (begin / numItemsBy2) * numItemsBy2 - numItemsBy4;
mBufferedRange.end = mBufferedRange.begin + numItems;
mMediaFeedNeedsToRun = true;
}
}
public void setFilter(MediaFilter filter) {
mMediaFilter = filter;
mMediaFilteredSet = null;
if (mListener != null) {
mListener.onFeedAboutToChange(this);
}
mMediaFeedNeedsToRun = true;
}
public void removeFilter() {
mMediaFilter = null;
mMediaFilteredSet = null;
if (mListener != null) {
mListener.onFeedAboutToChange(this);
updateListener(true);
}
mMediaFeedNeedsToRun = true;
}
public ArrayList<MediaSet> getMediaSets() {
return mMediaSets;
}
public MediaSet getMediaSet(final long setId) {
if (setId != Shared.INVALID) {
try {
int mMediaSetsSize = mMediaSets.size();
for (int i = 0; i < mMediaSetsSize; i++) {
if (mMediaSets.get(i).mId == setId) {
return mMediaSets.get(i);
}
}
} catch (Exception e) {
return null;
}
}
return null;
}
public MediaSet getFilteredSet() {
return mMediaFilteredSet;
}
public MediaSet addMediaSet(final long setId, DataSource dataSource) {
MediaSet mediaSet = new MediaSet(dataSource);
mediaSet.mId = setId;
mMediaSets.add(mediaSet);
if (mDataSourceThread != null && !mDataSourceThread.isAlive()) {
mDataSourceThread.start();
}
mMediaFeedNeedsToRun = true;
return mediaSet;
}
public DataSource getDataSource() {
return mDataSource;
}
public MediaClustering getClustering() {
if (mExpandedMediaSetIndex != Shared.INVALID && mExpandedMediaSetIndex < mMediaSets.size()) {
return mClusterSets.get(mMediaSets.get(mExpandedMediaSetIndex));
}
return null;
}
public ArrayList<Cluster> getClustersForSet(final MediaSet set) {
ArrayList<Cluster> clusters = null;
if (mClusterSets != null && mClusterSets.containsKey(set)) {
MediaClustering mediaClustering = mClusterSets.get(set);
if (mediaClustering != null) {
clusters = mediaClustering.getClusters();
}
}
return clusters;
}
public void addItemToMediaSet(MediaItem item, MediaSet mediaSet) {
item.mParentMediaSet = mediaSet;
mediaSet.addItem(item);
synchronized (mClusterSets) {
if (item.mClusteringState == MediaItem.NOT_CLUSTERED) {
MediaClustering clustering = mClusterSets.get(mediaSet);
if (clustering == null) {
clustering = new MediaClustering(mediaSet.isPicassaAlbum());
mClusterSets.put(mediaSet, clustering);
}
clustering.setTimeRange(mediaSet.mMaxTimestamp - mediaSet.mMinTimestamp, mediaSet.getNumExpectedItems());
clustering.addItemForClustering(item);
item.mClusteringState = MediaItem.CLUSTERED;
}
}
mMediaFeedNeedsToRun = true;
}
public void performOperation(final int operation, final ArrayList<MediaBucket> mediaBuckets, final Object data) {
int numBuckets = mediaBuckets.size();
final ArrayList<MediaBucket> copyMediaBuckets = new ArrayList<MediaBucket>(numBuckets);
for (int i = 0; i < numBuckets; ++i) {
copyMediaBuckets.add(mediaBuckets.get(i));
}
if (operation == OPERATION_DELETE && mListener != null) {
mListener.onFeedAboutToChange(this);
}
Thread operationThread = new Thread(new Runnable() {
public void run() {
ArrayList<MediaBucket> mediaBuckets = copyMediaBuckets;
if (operation == OPERATION_DELETE) {
int numBuckets = mediaBuckets.size();
for (int i = 0; i < numBuckets; ++i) {
MediaBucket bucket = mediaBuckets.get(i);
MediaSet set = bucket.mediaSet;
ArrayList<MediaItem> items = bucket.mediaItems;
if (set != null && items == null) {
// Remove the entire bucket.
removeMediaSet(set);
} else if (set != null && items != null) {
// We need to remove these items from the set.
int numItems = items.size();
// We also need to delete the items from the
// cluster.
MediaClustering clustering = mClusterSets.get(set);
for (int j = 0; j < numItems; ++j) {
MediaItem item = items.get(j);
removeItemFromMediaSet(item, set);
if (clustering != null) {
clustering.removeItemFromClustering(item);
}
}
set.updateNumExpectedItems();
set.generateTitle(true);
}
}
updateListener(true);
mMediaFeedNeedsToRun = true;
if (mDataSource != null) {
mDataSource.performOperation(OPERATION_DELETE, mediaBuckets, null);
}
} else {
mDataSource.performOperation(operation, mediaBuckets, data);
}
}
});
operationThread.setName("Operation " + operation);
operationThread.start();
}
public void removeMediaSet(MediaSet set) {
synchronized (mMediaSets) {
mMediaSets.remove(set);
}
mMediaFeedNeedsToRun = true;
}
private void removeItemFromMediaSet(MediaItem item, MediaSet mediaSet) {
mediaSet.removeItem(item);
synchronized (mClusterSets) {
MediaClustering clustering = mClusterSets.get(mediaSet);
if (clustering != null) {
clustering.removeItemFromClustering(item);
}
}
mMediaFeedNeedsToRun = true;
}
public void updateListener(boolean needsLayout) {
mListenerNeedsUpdate = true;
mListenerNeedsLayout = needsLayout;
}
public int getNumSlots() {
int currentMediaSetIndex = mExpandedMediaSetIndex;
ArrayList<MediaSet> mediaSets = mMediaSets;
int mediaSetsSize = mediaSets.size();
if (mInClusteringMode == false) {
if (currentMediaSetIndex == Shared.INVALID || currentMediaSetIndex >= mediaSetsSize) {
return mediaSetsSize;
} else {
MediaSet setToUse = (mMediaFilteredSet == null) ? mediaSets.get(currentMediaSetIndex) : mMediaFilteredSet;
return setToUse.getNumItems();
}
} else if (currentMediaSetIndex != Shared.INVALID && currentMediaSetIndex < mediaSetsSize) {
MediaSet set = mediaSets.get(currentMediaSetIndex);
MediaClustering clustering = mClusterSets.get(set);
if (clustering != null) {
return clustering.getClustersForDisplay().size();
}
}
return 0;
}
public MediaSet getSetForSlot(int slotIndex) {
if (slotIndex < 0) {
return null;
}
ArrayList<MediaSet> mediaSets = mMediaSets;
int mediaSetsSize = mediaSets.size();
int currentMediaSetIndex = mExpandedMediaSetIndex;
if (mInClusteringMode == false) {
if (currentMediaSetIndex == Shared.INVALID || currentMediaSetIndex >= mediaSetsSize) {
if (slotIndex >= mediaSetsSize) {
return null;
}
return mMediaSets.get(slotIndex);
}
if (mSingleWrapper.getNumItems() == 0) {
mSingleWrapper.addItem(null);
}
MediaSet setToUse = (mMediaFilteredSet == null) ? mMediaSets.get(currentMediaSetIndex) : mMediaFilteredSet;
ArrayList<MediaItem> items = setToUse.getItems();
if (slotIndex >= setToUse.getNumItems()) {
return null;
}
mSingleWrapper.getItems().set(0, items.get(slotIndex));
return mSingleWrapper;
} else if (currentMediaSetIndex != Shared.INVALID && currentMediaSetIndex < mediaSetsSize) {
MediaSet set = mediaSets.get(currentMediaSetIndex);
MediaClustering clustering = mClusterSets.get(set);
if (clustering != null) {
ArrayList<MediaClustering.Cluster> clusters = clustering.getClustersForDisplay();
if (clusters.size() > slotIndex) {
MediaClustering.Cluster cluster = clusters.get(slotIndex);
cluster.generateCaption(mContext);
return cluster;
}
}
}
return null;
}
public boolean getWaitingForMediaScanner() {
return mWaitingForMediaScanner;
}
public boolean isLoading() {
return mLoading;
}
public void start() {
final MediaFeed feed = this;
mLoading = true;
mDataSourceThread = new Thread(this);
mDataSourceThread.setName("MediaFeed");
mAlbumSourceThread = new Thread(new Runnable() {
public void run() {
if (mContext == null)
return;
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
DataSource dataSource = mDataSource;
// We must wait while the SD card is mounted or the MediaScanner
// is running.
if (dataSource != null) {
dataSource.loadMediaSets(feed);
}
mWaitingForMediaScanner = false;
while (ImageManager.isMediaScannerScanning(mContext.getContentResolver())) {
// MediaScanner is still running, wait
if (Thread.interrupted())
return;
mWaitingForMediaScanner = true;
try {
if (mContext == null)
return;
showToast(mContext.getResources().getString(R.string.initializing), Toast.LENGTH_LONG);
Thread.sleep(6000);
} catch (InterruptedException e) {
return;
}
}
if (mWaitingForMediaScanner) {
showToast(mContext.getResources().getString(R.string.loading_new), Toast.LENGTH_LONG);
mWaitingForMediaScanner = false;
if (dataSource != null) {
dataSource.loadMediaSets(feed);
}
}
mLoading = false;
}
});
mAlbumSourceThread.setName("MediaSets");
mAlbumSourceThread.start();
}
private void showToast(final String string, final int duration) {
showToast(string, duration, false);
}
private void showToast(final String string, final int duration, final boolean centered) {
if (mContext != null && !((Gallery) mContext).isPaused()) {
((Gallery) mContext).getHandler().post(new Runnable() {
public void run() {
if (mContext != null) {
Toast toast = Toast.makeText(mContext, string, duration);
if (centered) {
toast.setGravity(Gravity.CENTER, 0, 0);
}
toast.show();
}
}
});
}
}
public void run() {
DataSource dataSource = mDataSource;
int sleepMs = 10;
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
if (dataSource != null) {
while (!Thread.interrupted()) {
if (mListenerNeedsUpdate) {
mListenerNeedsUpdate = false;
if (mListener != null)
mListener.onFeedChanged(this, mListenerNeedsLayout);
try {
Thread.sleep(sleepMs);
} catch (InterruptedException e) {
return;
}
} else {
if (mWaitingForMediaScanner) {
synchronized (mMediaSets) {
mMediaSets.clear();
}
}
try {
Thread.sleep(sleepMs);
} catch (InterruptedException e) {
return;
}
}
sleepMs = 300;
if (!mMediaFeedNeedsToRun)
continue;
if (((Gallery) mContext).isPaused())
continue;
mMediaFeedNeedsToRun = false;
ArrayList<MediaSet> mediaSets = mMediaSets;
synchronized (mediaSets) {
int expandedSetIndex = mExpandedMediaSetIndex;
if (expandedSetIndex >= mMediaSets.size()) {
expandedSetIndex = Shared.INVALID;
}
if (expandedSetIndex == Shared.INVALID) {
// We purge the sets outside this visibleRange.
int numSets = mediaSets.size();
IndexRange visibleRange = mVisibleRange;
IndexRange bufferedRange = mBufferedRange;
boolean scanMediaSets = true;
for (int i = 0; i < numSets; ++i) {
if (i >= visibleRange.begin && i <= visibleRange.end && scanMediaSets) {
MediaSet set = mediaSets.get(i);
int numItemsLoaded = set.mNumItemsLoaded;
if (numItemsLoaded < set.getNumExpectedItems() && numItemsLoaded < 8) {
dataSource.loadItemsForSet(this, set, numItemsLoaded, 8);
if (set.getNumExpectedItems() == 0) {
mediaSets.remove(set);
break;
}
if (mListener != null) {
mListener.onFeedChanged(this, false);
}
sleepMs = 100;
scanMediaSets = false;
}
if (!set.setContainsValidItems()) {
mediaSets.remove(set);
if (mListener != null) {
mListener.onFeedChanged(this, false);
}
break;
}
}
}
numSets = mediaSets.size();
for (int i = 0; i < numSets; ++i) {
MediaSet set = mediaSets.get(i);
if (i >= bufferedRange.begin && i <= bufferedRange.end) {
if (scanMediaSets) {
int numItemsLoaded = set.mNumItemsLoaded;
if (numItemsLoaded < set.getNumExpectedItems() && numItemsLoaded < 8) {
dataSource.loadItemsForSet(this, set, numItemsLoaded, 8);
if (set.getNumExpectedItems() == 0) {
mediaSets.remove(set);
break;
}
if (mListener != null) {
mListener.onFeedChanged(this, false);
}
sleepMs = 100;
scanMediaSets = false;
}
}
} else if (i < bufferedRange.begin || i > bufferedRange.end) {
// Purge this set to its initial status.
MediaClustering clustering = mClusterSets.get(set);
if (clustering != null) {
clustering.clear();
mClusterSets.remove(set);
}
if (set.getNumItems() != 0)
set.clear();
}
}
}
if (expandedSetIndex != Shared.INVALID) {
int numSets = mMediaSets.size();
for (int i = 0; i < numSets; ++i) {
// Purge other sets.
if (i != expandedSetIndex) {
MediaSet set = mediaSets.get(i);
MediaClustering clustering = mClusterSets.get(set);
if (clustering != null) {
clustering.clear();
mClusterSets.remove(set);
}
if (set.getNumItems() != 0)
set.clear();
}
}
// Make sure all the items are loaded for the album.
int numItemsLoaded = mediaSets.get(expandedSetIndex).mNumItemsLoaded;
int requestedItems = mVisibleRange.end;
// requestedItems count changes in clustering mode.
if (mInClusteringMode && mClusterSets != null) {
requestedItems = 0;
MediaClustering clustering = mClusterSets.get(mediaSets.get(expandedSetIndex));
if (clustering != null) {
ArrayList<Cluster> clusters = clustering.getClustersForDisplay();
int numClusters = clusters.size();
for (int i = 0; i < numClusters; i++) {
requestedItems += clusters.get(i).getNumExpectedItems();
}
}
}
MediaSet set = mediaSets.get(expandedSetIndex);
if (numItemsLoaded < set.getNumExpectedItems()) {
// We perform calculations for a window that gets anchored to a multiple of NUM_ITEMS_LOOKAHEAD.
// The start of the window is 0, x, 2x, 3x ... etc where x = NUM_ITEMS_LOOKAHEAD.
dataSource.loadItemsForSet(this, set, numItemsLoaded, (requestedItems / NUM_ITEMS_LOOKAHEAD)
* NUM_ITEMS_LOOKAHEAD + NUM_ITEMS_LOOKAHEAD);
if (set.getNumExpectedItems() == 0) {
mediaSets.remove(set);
mListener.onFeedChanged(this, false);
}
if (numItemsLoaded != set.mNumItemsLoaded && mListener != null) {
mListener.onFeedChanged(this, false);
}
}
}
MediaFilter filter = mMediaFilter;
if (filter != null && mMediaFilteredSet == null) {
if (expandedSetIndex != Shared.INVALID) {
MediaSet set = mediaSets.get(expandedSetIndex);
ArrayList<MediaItem> items = set.getItems();
int numItems = set.getNumItems();
MediaSet filteredSet = new MediaSet();
filteredSet.setNumExpectedItems(numItems);
mMediaFilteredSet = filteredSet;
for (int i = 0; i < numItems; ++i) {
MediaItem item = items.get(i);
if (filter.pass(item)) {
filteredSet.addItem(item);
}
}
filteredSet.updateNumExpectedItems();
filteredSet.generateTitle(true);
}
updateListener(true);
}
}
}
}
}
public void expandMediaSet(int mediaSetIndex) {
// We need to check if this slot can be focused or not.
if (mListener != null) {
mListener.onFeedAboutToChange(this);
}
if (mExpandedMediaSetIndex > 0 && mediaSetIndex == Shared.INVALID) {
// We are collapsing a previously expanded media set
if (mediaSetIndex < mMediaSets.size() && mExpandedMediaSetIndex >= 0 && mExpandedMediaSetIndex < mMediaSets.size()) {
MediaSet set = mMediaSets.get(mExpandedMediaSetIndex);
if (set.getNumItems() == 0) {
set.clear();
}
}
}
mExpandedMediaSetIndex = mediaSetIndex;
if (mediaSetIndex < mMediaSets.size() && mediaSetIndex >= 0) {
// Notify Picasa that the user entered the album.
// MediaSet set = mMediaSets.get(mediaSetIndex);
// PicasaService.requestSync(mContext,
// PicasaService.TYPE_ALBUM_PHOTOS, set.mPicasaAlbumId);
}
updateListener(true);
mMediaFeedNeedsToRun = true;
}
public boolean canExpandSet(int slotIndex) {
int mediaSetIndex = slotIndex;
if (mediaSetIndex < mMediaSets.size() && mediaSetIndex >= 0) {
MediaSet set = mMediaSets.get(mediaSetIndex);
if (set.getNumItems() > 0) {
MediaItem item = set.getItems().get(0);
if (item.mId == Shared.INVALID) {
return false;
}
return true;
}
}
return false;
}
public boolean hasExpandedMediaSet() {
return (mExpandedMediaSetIndex != Shared.INVALID);
}
public boolean restorePreviousClusteringState() {
boolean retVal = disableClusteringIfNecessary();
if (retVal) {
if (mListener != null) {
mListener.onFeedAboutToChange(this);
}
updateListener(true);
mMediaFeedNeedsToRun = true;
}
return retVal;
}
private boolean disableClusteringIfNecessary() {
if (mInClusteringMode) {
// Disable clustering.
mInClusteringMode = false;
mMediaFeedNeedsToRun = true;
return true;
}
return false;
}
public boolean isClustered() {
return mInClusteringMode;
}
public MediaSet getCurrentSet() {
if (mExpandedMediaSetIndex != Shared.INVALID && mExpandedMediaSetIndex < mMediaSets.size()) {
return mMediaSets.get(mExpandedMediaSetIndex);
}
return null;
}
public void performClustering() {
if (mListener != null) {
mListener.onFeedAboutToChange(this);
}
MediaSet setToUse = null;
if (mExpandedMediaSetIndex != Shared.INVALID || mExpandedMediaSetIndex < mMediaSets.size()) {
setToUse = mMediaSets.get(mExpandedMediaSetIndex);
}
if (setToUse != null) {
MediaClustering clustering = null;
synchronized (mClusterSets) {
// Make sure the computation is completed to the end.
clustering = mClusterSets.get(setToUse);
if (clustering != null) {
clustering.compute(null, true);
} else {
return;
}
}
mInClusteringMode = true;
mMediaFeedNeedsToRun = true;
updateListener(true);
}
}
public void moveSetToFront(MediaSet mediaSet) {
ArrayList<MediaSet> mediaSets = mMediaSets;
int numSets = mediaSets.size();
if (numSets == 0) {
mediaSets.add(mediaSet);
return;
}
MediaSet setToFind = mediaSets.get(0);
if (setToFind == mediaSet) {
return;
}
mediaSets.set(0, mediaSet);
int indexToSwapTill = -1;
for (int i = 1; i < numSets; ++i) {
MediaSet set = mediaSets.get(i);
if (set == mediaSet) {
mediaSets.set(i, setToFind);
indexToSwapTill = i;
break;
}
}
if (indexToSwapTill != Shared.INVALID) {
for (int i = indexToSwapTill; i > 1; --i) {
MediaSet setEnd = mediaSets.get(i);
MediaSet setPrev = mediaSets.get(i - 1);
mediaSets.set(i, setPrev);
mediaSets.set(i - 1, setEnd);
}
}
mMediaFeedNeedsToRun = true;
}
public MediaSet replaceMediaSet(long setId, DataSource dataSource) {
MediaSet mediaSet = new MediaSet(dataSource);
mediaSet.mId = setId;
ArrayList<MediaSet> mediaSets = mMediaSets;
int numSets = mediaSets.size();
for (int i = 0; i < numSets; ++i) {
final MediaSet thisSet = mediaSets.get(i);
if (thisSet.mId == setId) {
mediaSet.mName = thisSet.mName;
mediaSet.mHasImages = thisSet.mHasImages;
mediaSet.mHasVideos = thisSet.mHasVideos;
mediaSets.set(i, mediaSet);
break;
}
}
mMediaFeedNeedsToRun = true;
return mediaSet;
}
public void setSingleImageMode(boolean singleImageMode) {
mSingleImageMode = singleImageMode;
}
public boolean isSingleImageMode() {
return mSingleImageMode;
}
public MediaSet getExpandedMediaSet() {
if (mExpandedMediaSetIndex == Shared.INVALID)
return null;
if (mExpandedMediaSetIndex >= mMediaSets.size())
return null;
return mMediaSets.get(mExpandedMediaSetIndex);
}
}