/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.cooliris.media;
import java.util.ArrayList;
public class MediaSet {
public static final int TYPE_SMART = 0;
public static final int TYPE_FOLDER = 1;
public static final int TYPE_USERDEFINED = 2;
public long mId;
public String mName;
public boolean mFlagForDelete;
public boolean mHasImages;
public boolean mHasVideos;
// The type of the media set. A smart media set is an automatically
// generated media set. For example, the most recently
// viewed items media set is a media set that gets populated by the contents
// of a folder. A user defined media set
// is a set that is made by the user. This would typically correspond to
// media items belonging to an event.
public int mType;
// The min and max date taken and added at timestamps.
public long mMinTimestamp = Long.MAX_VALUE;
public long mMaxTimestamp = 0;
public long mMinAddedTimestamp = Long.MAX_VALUE;
public long mMaxAddedTimestamp = 0;
// The latitude and longitude of the min latitude point.
public double mMinLatLatitude = LocationMediaFilter.LAT_MAX;
public double mMinLatLongitude;
// The latitude and longitude of the max latitude point.
public double mMaxLatLatitude = LocationMediaFilter.LAT_MIN;
public double mMaxLatLongitude;
// The latitude and longitude of the min longitude point.
public double mMinLonLatitude;
public double mMinLonLongitude = LocationMediaFilter.LON_MAX;
// The latitude and longitude of the max longitude point.
public double mMaxLonLatitude;
public double mMaxLonLongitude = LocationMediaFilter.LON_MIN;
// Reverse geocoding the latitude, longitude and getting an address or
// location.
public String mReverseGeocodedLocation;
// Set to true if at least one item in the set has a valid latitude and
// longitude.
public boolean mLatLongDetermined = false;
public boolean mReverseGeocodedLocationComputed = false;
public boolean mReverseGeocodedLocationRequestMade = false;
public String mTitleString;
public String mTruncTitleString;
public String mNoCountTitleString;
public String mEditUri = null;
public long mPicasaAlbumId = Shared.INVALID;
public boolean mIsLocal = true;
public DataSource mDataSource;
public boolean mSyncPending = false;
private ArrayList<MediaItem> mItems;
private LongSparseArray<MediaItem> mItemsLookup;
private LongSparseArray<MediaItem> mItemsLookupVideo;
public int mNumItemsLoaded = 0;
// mNumExpectedItems is preset to how many items are expected to be in the
// set as it is used to visually
// display the number of items in the set and we don't want this display to
// keep changing as items get loaded.
private int mNumExpectedItems = 0;
private boolean mNumExpectedItemsCountAccurate = false;
private int mCurrentLocation = 0;
public MediaSet() {
this(null);
}
public MediaSet(DataSource dataSource) {
mItems = new ArrayList<MediaItem>(16);
mItemsLookup = new LongSparseArray<MediaItem>();
mItemsLookup.clear();
mItemsLookupVideo = new LongSparseArray<MediaItem>();
mItemsLookupVideo.clear();
mDataSource = dataSource;
// TODO(Venkat): Can we move away from this dummy item setup?
MediaItem item = new MediaItem();
item.mId = Shared.INVALID;
item.mParentMediaSet = this;
mItems.add(item);
mNumExpectedItems = 16;
}
/**
* @return underlying ArrayList of MediaItems. Use only for iteration (read
* operations) on the ArrayList.
*/
public ArrayList<MediaItem> getItems() {
return mItems;
}
public void setNumExpectedItems(int numExpectedItems) {
mItems.ensureCapacity(numExpectedItems);
mNumExpectedItems = numExpectedItems;
mNumExpectedItemsCountAccurate = true;
}
public int getNumExpectedItems() {
return mNumExpectedItems;
}
public boolean setContainsValidItems() {
if (mNumExpectedItems == 0)
return false;
return true;
}
public void updateNumExpectedItems() {
mNumExpectedItems = mNumItemsLoaded;
mNumExpectedItemsCountAccurate = true;
}
public int getNumItems() {
return mItems.size();
}
public void clear() {
mItems.clear();
MediaItem item = new MediaItem();
item.mId = Shared.INVALID;
item.mParentMediaSet = this;
mItems.add(item);
mNumExpectedItems = 16;
refresh();
mItemsLookup.clear();
mItemsLookupVideo.clear();
}
/**
* Generates the label for the MediaSet.
*/
public void generateTitle(final boolean truncateTitle) {
if (mName == null) {
mName = "";
}
String size = (mNumExpectedItemsCountAccurate) ? " (" + mNumExpectedItems + ")" : "";
mTitleString = mName + size;
if (truncateTitle) {
int length = mName.length();
mTruncTitleString = (length > 16) ? mName.substring(0, 12) + "..." + mName.substring(length - 4, length) + size : mName
+ size;
mNoCountTitleString = mName;
} else {
mTruncTitleString = mTitleString;
}
}
/**
* Adds a MediaItem to this set, and increments the load count.
* Additionally, it also recomputes the location bounds and time range of
* the media set.
*/
public void addItem(final MediaItem itemToAdd) {
// Important to not set the parentMediaSet in here as temporary
// MediaSet's are occasionally
// created and we do not want the MediaItem updated as a result of that.
if (itemToAdd == null) {
return;
}
final LongSparseArray<MediaItem> lookup = (itemToAdd.getMediaType() == MediaItem.MEDIA_TYPE_IMAGE) ? mItemsLookup
: mItemsLookupVideo;
MediaItem lookupItem = lookup.get(itemToAdd.mId);
if (lookupItem != null && !lookupItem.mFilePath.equals(itemToAdd.mFilePath)) {
lookupItem = null;
}
final MediaItem item = (lookupItem == null) ? itemToAdd : lookupItem;
item.mFlagForDelete = false;
if (mItems.size() == 0) {
mItems.add(item);
} else if (mItems.get(0).mId == -1L) {
mItems.set(0, item);
} else {
if (mItems.size() > mCurrentLocation) {
mItems.set(mCurrentLocation, item);
} else {
mItems.add(mCurrentLocation, item);
}
}
if (item.mId != Shared.INVALID) {
if (lookupItem == null) {
lookup.put(item.mId, item);
}
++mNumItemsLoaded;
++mCurrentLocation;
}
if (item.isDateTakenValid()) {
long dateTaken = item.mDateTakenInMs;
if (dateTaken < mMinTimestamp) {
mMinTimestamp = dateTaken;
}
if (dateTaken > mMaxTimestamp) {
mMaxTimestamp = dateTaken;
}
} else if (item.isDateAddedValid()) {
long dateAdded = item.mDateAddedInSec * 1000;
if (dateAdded < mMinAddedTimestamp) {
mMinAddedTimestamp = dateAdded;
}
if (dateAdded > mMaxAddedTimestamp) {
mMaxAddedTimestamp = dateAdded;
}
}
// Determining the latitude longitude bounds of the set and setting the
// location string.
if (!item.isLatLongValid()) {
return;
}
double itemLatitude = item.mLatitude;
double itemLongitude = item.mLongitude;
if (mMinLatLatitude > itemLatitude) {
mMinLatLatitude = itemLatitude;
mMinLatLongitude = itemLongitude;
mLatLongDetermined = true;
}
if (mMaxLatLatitude < itemLatitude) {
mMaxLatLatitude = itemLatitude;
mMaxLatLongitude = itemLongitude;
mLatLongDetermined = true;
}
if (mMinLonLongitude > itemLongitude) {
mMinLonLatitude = itemLatitude;
mMinLonLongitude = itemLongitude;
mLatLongDetermined = true;
}
if (mMaxLonLongitude < itemLongitude) {
mMaxLonLatitude = itemLatitude;
mMaxLonLongitude = itemLongitude;
mLatLongDetermined = true;
}
}
/**
* Removes a MediaItem if present in the MediaSet.
*
* @return true if the item was removed, false if removal failed or item was
* not present in the set.
*/
public boolean removeItem(final MediaItem itemToRemove) {
synchronized (mItems) {
if (mItems.remove(itemToRemove)) {
--mNumExpectedItems;
--mNumItemsLoaded;
--mCurrentLocation;
final LongSparseArray<MediaItem> lookup = (itemToRemove.getMediaType() == MediaItem.MEDIA_TYPE_IMAGE) ? mItemsLookup
: mItemsLookupVideo;
lookup.remove(itemToRemove.mId);
return true;
}
return false;
}
}
public void removeDuplicate(final MediaItem itemToRemove) {
synchronized (mItems) {
int numItems = mItems.size();
boolean foundItem = false;
for (int i = 0; i < numItems; ++i) {
final MediaItem item = mItems.get(i);
if (item == itemToRemove) {
if (foundItem == false) {
foundItem = true;
} else {
mItems.remove(i);
--mNumExpectedItems;
--mNumItemsLoaded;
--mCurrentLocation;
break;
}
}
}
}
}
/**
* @return true if this MediaSet contains the argument MediaItem.
*/
public boolean lookupContainsItem(final MediaItem item) {
final LongSparseArray<MediaItem> lookupTable = (item.getMediaType() == MediaItem.MEDIA_TYPE_IMAGE) ? mItemsLookup
: mItemsLookupVideo;
MediaItem lookUp = lookupTable.get(item.mId);
if (lookUp != null && lookUp.mFilePath.equals(item.mFilePath)) {
return true;
} else {
return false;
}
}
/**
* @return true if the title string is truncated.
*/
public boolean isTruncated() {
return (mTitleString != null && !mTitleString.equals(mTruncTitleString));
}
/**
* @return true if timestamps are available for this set.
*/
public boolean areTimestampsAvailable() {
return (mMinTimestamp < Long.MAX_VALUE && mMaxTimestamp > 0);
}
/**
* @return true if the added timestamps are available for this set.
*/
public boolean areAddedTimestampsAvailable() {
return (mMinAddedTimestamp < Long.MAX_VALUE && mMaxAddedTimestamp > 0);
}
/**
* @return true if this set of items corresponds to Picassa items.
*/
public boolean isPicassaSet() {
// 2 cases:-
// 1. This set is just a Picassa Album, and all its items are therefore
// from Picassa.
// 2. This set is a random collection of items and each item is a
// Picassa item.
if (isPicassaAlbum()) {
return true;
}
int numItems = mItems.size();
for (int i = 0; i < numItems; i++) {
if (!mItems.get(i).isPicassaItem()) {
return false;
}
}
return true;
}
/**
* @return true if this set is a Picassa album.
*/
public boolean isPicassaAlbum() {
return (mPicasaAlbumId != Shared.INVALID);
}
public void refresh() {
mNumItemsLoaded = 0;
mCurrentLocation = 0;
final ArrayList<MediaItem> items = mItems;
final int numItems = items.size();
for (int i = 0; i < numItems; ++i) {
MediaItem item = items.get(i);
item.mFlagForDelete = true;
}
}
public void checkForDeletedItems() {
final ArrayList<MediaItem> items = mItems;
final ArrayList<MediaItem> itemsToDelete = new ArrayList<MediaItem>();
synchronized (items) {
final int numItems = items.size();
for (int i = 0; i < numItems; ++i) {
MediaItem item = items.get(i);
if (item.mFlagForDelete) {
itemsToDelete.add(item);
}
}
}
final int numItemsToDelete = itemsToDelete.size();
for (int i = 0; i < numItemsToDelete; ++i) {
removeItem(itemsToDelete.get(i));
}
}
}