/*
* 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.android.calendar.agenda;
import com.android.calendar.CalendarController;
import com.android.calendar.R;
import com.android.calendar.Utils;
import com.android.calendar.CalendarController.EventType;
import com.android.calendar.CalendarController.ViewType;
import com.android.calendar.StickyHeaderListView;
import android.content.AsyncQueryHandler;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.res.Resources;
import android.database.Cursor;
import android.net.Uri;
import android.os.Handler;
import android.provider.CalendarContract;
import android.provider.CalendarContract.Attendees;
import android.provider.CalendarContract.Calendars;
import android.provider.CalendarContract.Instances;
import android.text.format.DateUtils;
import android.text.format.Time;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AbsListView.OnScrollListener;
import android.widget.BaseAdapter;
import android.widget.TextView;
import java.util.Formatter;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Locale;
import java.util.concurrent.ConcurrentLinkedQueue;
/*
Bugs Bugs Bugs:
- At rotation and launch time, the initial position is not set properly. This code is calling
listview.setSelection() in 2 rapid secessions but it dropped or didn't process the first one.
- Scroll using trackball isn't repositioning properly after a new adapter is added.
- Track ball clicks at the header/footer doesn't work.
- Potential ping pong effect if the prefetch window is big and data is limited
- Add index in calendar provider
ToDo ToDo ToDo:
Get design of header and footer from designer
Make scrolling smoother.
Test for correctness
Loading speed
Check for leaks and excessive allocations
*/
public class AgendaWindowAdapter extends BaseAdapter
implements StickyHeaderListView.HeaderIndexer, StickyHeaderListView.HeaderHeightListener{
static final boolean BASICLOG = false;
static final boolean DEBUGLOG = false;
private static final String TAG = "AgendaWindowAdapter";
private static final String AGENDA_SORT_ORDER =
CalendarContract.Instances.START_DAY + " ASC, " +
CalendarContract.Instances.BEGIN + " ASC, " +
CalendarContract.Events.TITLE + " ASC";
public static final int INDEX_INSTANCE_ID = 0;
public static final int INDEX_TITLE = 1;
public static final int INDEX_EVENT_LOCATION = 2;
public static final int INDEX_ALL_DAY = 3;
public static final int INDEX_HAS_ALARM = 4;
public static final int INDEX_COLOR = 5;
public static final int INDEX_RRULE = 6;
public static final int INDEX_BEGIN = 7;
public static final int INDEX_END = 8;
public static final int INDEX_EVENT_ID = 9;
public static final int INDEX_START_DAY = 10;
public static final int INDEX_END_DAY = 11;
public static final int INDEX_SELF_ATTENDEE_STATUS = 12;
public static final int INDEX_ORGANIZER = 13;
public static final int INDEX_OWNER_ACCOUNT = 14;
public static final int INDEX_CAN_ORGANIZER_RESPOND= 15;
public static final int INDEX_TIME_ZONE = 16;
private static final String[] PROJECTION = new String[] {
Instances._ID, // 0
Instances.TITLE, // 1
Instances.EVENT_LOCATION, // 2
Instances.ALL_DAY, // 3
Instances.HAS_ALARM, // 4
Instances.CALENDAR_COLOR, // 5
Instances.RRULE, // 6
Instances.BEGIN, // 7
Instances.END, // 8
Instances.EVENT_ID, // 9
Instances.START_DAY, // 10 Julian start day
Instances.END_DAY, // 11 Julian end day
Instances.SELF_ATTENDEE_STATUS, // 12
Instances.ORGANIZER, // 13
Instances.OWNER_ACCOUNT, // 14
Instances.CAN_ORGANIZER_RESPOND, // 15
Instances.EVENT_TIMEZONE, // 16
};
// Listview may have a bug where the index/position is not consistent when there's a header.
// position == positionInListView - OFF_BY_ONE_BUG
// TODO Need to look into this.
private static final int OFF_BY_ONE_BUG = 1;
private static final int MAX_NUM_OF_ADAPTERS = 5;
private static final int IDEAL_NUM_OF_EVENTS = 50;
private static final int MIN_QUERY_DURATION = 7; // days
private static final int MAX_QUERY_DURATION = 60; // days
private static final int PREFETCH_BOUNDARY = 1;
/** Times to auto-expand/retry query after getting no data */
private static final int RETRIES_ON_NO_DATA = 1;
private Context mContext;
private Resources mResources;
private QueryHandler mQueryHandler;
private AgendaListView mAgendaListView;
/** The sum of the rows in all the adapters */
private int mRowCount;
/** The number of times we have queried and gotten no results back */
private int mEmptyCursorCount;
/** Cached value of the last used adapter */
private DayAdapterInfo mLastUsedInfo;
private final LinkedList<DayAdapterInfo> mAdapterInfos =
new LinkedList<DayAdapterInfo>();
private final ConcurrentLinkedQueue<QuerySpec> mQueryQueue =
new ConcurrentLinkedQueue<QuerySpec>();
private TextView mHeaderView;
private TextView mFooterView;
private boolean mDoneSettingUpHeaderFooter = false;
private final boolean mIsTabletConfig;
boolean mCleanQueryInitiated = false;
private int mStickyHeaderSize = 44; // Initial size big enough for it to work
/**
* When the user scrolled to the top, a query will be made for older events
* and this will be incremented. Don't make more requests if
* mOlderRequests > mOlderRequestsProcessed.
*/
private int mOlderRequests;
/** Number of "older" query that has been processed. */
private int mOlderRequestsProcessed;
/**
* When the user scrolled to the bottom, a query will be made for newer
* events and this will be incremented. Don't make more requests if
* mNewerRequests > mNewerRequestsProcessed.
*/
private int mNewerRequests;
/** Number of "newer" query that has been processed. */
private int mNewerRequestsProcessed;
// Note: Formatter is not thread safe. Fine for now as it is only used by the main thread.
private Formatter mFormatter;
private StringBuilder mStringBuilder;
private String mTimeZone;
// defines if to pop-up the current event when the agenda is first shown
private boolean mShowEventOnStart;
private Runnable mTZUpdater = new Runnable() {
@Override
public void run() {
mTimeZone = Utils.getTimeZone(mContext, this);
notifyDataSetChanged();
}
};
private boolean mShuttingDown;
private boolean mHideDeclined;
// Used to stop a fling motion if the ListView is set to a specific position
int mListViewScrollState = OnScrollListener.SCROLL_STATE_IDLE;
/** The current search query, or null if none */
private String mSearchQuery;
private long mSelectedInstanceId = -1;
private final int mSelectedItemBackgroundColor;
private final int mSelectedItemTextColor;
// Types of Query
private static final int QUERY_TYPE_OLDER = 0; // Query for older events
private static final int QUERY_TYPE_NEWER = 1; // Query for newer events
private static final int QUERY_TYPE_CLEAN = 2; // Delete everything and query around a date
private static class QuerySpec {
long queryStartMillis;
Time goToTime;
int start;
int end;
String searchQuery;
int queryType;
long id;
public QuerySpec(int queryType) {
this.queryType = queryType;
id = -1;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + end;
result = prime * result + (int) (queryStartMillis ^ (queryStartMillis >>> 32));
result = prime * result + queryType;
result = prime * result + start;
if (searchQuery != null) {
result = prime * result + searchQuery.hashCode();
}
if (goToTime != null) {
long goToTimeMillis = goToTime.toMillis(false);
result = prime * result + (int) (goToTimeMillis ^ (goToTimeMillis >>> 32));
}
result = prime * result + (int)id;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
QuerySpec other = (QuerySpec) obj;
if (end != other.end || queryStartMillis != other.queryStartMillis
|| queryType != other.queryType || start != other.start
|| Utils.equals(searchQuery, other.searchQuery) || id != other.id) {
return false;
}
if (goToTime != null) {
if (goToTime.toMillis(false) != other.goToTime.toMillis(false)) {
return false;
}
} else {
if (other.goToTime != null) {
return false;
}
}
return true;
}
}
static class EventInfo {
long begin;
long end;
long id;
int startDay;
boolean allDay;
}
static class DayAdapterInfo {
Cursor cursor;
AgendaByDayAdapter dayAdapter;
int start; // start day of the cursor's coverage
int end; // end day of the cursor's coverage
int offset; // offset in position in the list view
int size; // dayAdapter.getCount()
public DayAdapterInfo(Context context) {
dayAdapter = new AgendaByDayAdapter(context);
}
@Override
public String toString() {
// Static class, so the time in this toString will not reflect the
// home tz settings. This should only affect debugging.
Time time = new Time();
StringBuilder sb = new StringBuilder();
time.setJulianDay(start);
time.normalize(false);
sb.append("Start:").append(time.toString());
time.setJulianDay(end);
time.normalize(false);
sb.append(" End:").append(time.toString());
sb.append(" Offset:").append(offset);
sb.append(" Size:").append(size);
return sb.toString();
}
}
public AgendaWindowAdapter(Context context,
AgendaListView agendaListView, boolean showEventOnStart) {
mContext = context;
mResources = context.getResources();
mSelectedItemBackgroundColor = mResources
.getColor(R.color.agenda_selected_background_color);
mSelectedItemTextColor = mResources.getColor(R.color.agenda_selected_text_color);
mIsTabletConfig = Utils.getConfigBool(mContext, R.bool.tablet_config);
mTimeZone = Utils.getTimeZone(context, mTZUpdater);
mAgendaListView = agendaListView;
mQueryHandler = new QueryHandler(context.getContentResolver());
mStringBuilder = new StringBuilder(50);
mFormatter = new Formatter(mStringBuilder, Locale.getDefault());
mShowEventOnStart = showEventOnStart;
// Implies there is no sticky header
if (!mShowEventOnStart) {
mStickyHeaderSize = 0;
}
mSearchQuery = null;
LayoutInflater inflater = (LayoutInflater) context
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
mHeaderView = (TextView)inflater.inflate(R.layout.agenda_header_footer, null);
mFooterView = (TextView)inflater.inflate(R.layout.agenda_header_footer, null);
mHeaderView.setText(R.string.loading);
mAgendaListView.addHeaderView(mHeaderView);
}
// Method in Adapter
@Override
public int getViewTypeCount() {
return AgendaByDayAdapter.TYPE_LAST;
}
// Method in BaseAdapter
@Override
public boolean areAllItemsEnabled() {
return false;
}
// Method in Adapter
@Override
public int getItemViewType(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.dayAdapter.getItemViewType(position - info.offset);
} else {
return -1;
}
}
// Method in BaseAdapter
@Override
public boolean isEnabled(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.dayAdapter.isEnabled(position - info.offset);
} else {
return false;
}
}
// Abstract Method in BaseAdapter
public int getCount() {
return mRowCount;
}
// Abstract Method in BaseAdapter
public Object getItem(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.dayAdapter.getItem(position - info.offset);
} else {
return null;
}
}
// Method in BaseAdapter
@Override
public boolean hasStableIds() {
return true;
}
// Abstract Method in BaseAdapter
@Override
public long getItemId(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
int curPos = info.dayAdapter.getCursorPosition(position - info.offset);
if (curPos == Integer.MIN_VALUE) {
return -1;
}
// Regular event
if (curPos >= 0) {
info.cursor.moveToPosition(curPos);
return info.cursor.getLong(AgendaWindowAdapter.INDEX_EVENT_ID) << 20 +
info.cursor.getLong(AgendaWindowAdapter.INDEX_BEGIN);
}
// Day Header
return info.dayAdapter.findJulianDayFromPosition(position);
} else {
return -1;
}
}
// Abstract Method in BaseAdapter
public View getView(int position, View convertView, ViewGroup parent) {
if (position >= (mRowCount - PREFETCH_BOUNDARY)
&& mNewerRequests <= mNewerRequestsProcessed) {
if (DEBUGLOG) Log.e(TAG, "queryForNewerEvents: ");
mNewerRequests++;
queueQuery(new QuerySpec(QUERY_TYPE_NEWER));
}
if (position < PREFETCH_BOUNDARY
&& mOlderRequests <= mOlderRequestsProcessed) {
if (DEBUGLOG) Log.e(TAG, "queryForOlderEvents: ");
mOlderRequests++;
queueQuery(new QuerySpec(QUERY_TYPE_OLDER));
}
final View v;
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
int offset = position - info.offset;
v = info.dayAdapter.getView(offset, convertView,
parent);
// Turn on the past/present separator if the view is a day header
// and it is the first day with events after yesterday.
if (info.dayAdapter.isDayHeaderView(offset)) {
View simpleDivider = v.findViewById(R.id.top_divider_simple);
View pastPresentDivider = v.findViewById(R.id.top_divider_past_present);
if (info.dayAdapter.isFirstDayAfterYesterday(offset)) {
if (simpleDivider != null && pastPresentDivider != null) {
simpleDivider.setVisibility(View.GONE);
pastPresentDivider.setVisibility(View.VISIBLE);
}
} else if (simpleDivider != null && pastPresentDivider != null) {
simpleDivider.setVisibility(View.VISIBLE);
pastPresentDivider.setVisibility(View.GONE);
}
}
} else {
// TODO
Log.e(TAG, "BUG: getAdapterInfoByPosition returned null!!! " + position);
TextView tv = new TextView(mContext);
tv.setText("Bug! " + position);
v = tv;
}
// If this is not a tablet config don't do selection highlighting
if (!mIsTabletConfig) {
return v;
}
// Show selected marker if this is item is selected
boolean selected = false;
Object yy = v.getTag();
if (yy instanceof AgendaAdapter.ViewHolder) {
AgendaAdapter.ViewHolder vh = (AgendaAdapter.ViewHolder) yy;
selected = mSelectedInstanceId == vh.instanceId;
vh.selectedMarker.setVisibility((selected && mShowEventOnStart) ?
View.VISIBLE : View.GONE);
if (selected && mShowEventOnStart) {
mSelectedVH = vh;
v.setBackgroundColor(mSelectedItemBackgroundColor);
vh.title.setTextColor(mSelectedItemTextColor);
vh.when.setTextColor(mSelectedItemTextColor);
vh.where.setTextColor(mSelectedItemTextColor);
}
}
if (DEBUGLOG) {
Log.e(TAG, "getView " + position + " = " + getViewTitle(v));
}
return v;
}
private AgendaAdapter.ViewHolder mSelectedVH = null;
private int findEventPositionNearestTime(Time time, long id) {
if (DEBUGLOG) Log.e(TAG, "findEventPositionNearestTime " + time + " id " + id);
DayAdapterInfo info = getAdapterInfoByTime(time);
if (info != null) {
return info.offset + info.dayAdapter.findEventPositionNearestTime(time, id);
} else {
return -1;
}
}
protected DayAdapterInfo getAdapterInfoByPosition(int position) {
synchronized (mAdapterInfos) {
if (mLastUsedInfo != null && mLastUsedInfo.offset <= position
&& position < (mLastUsedInfo.offset + mLastUsedInfo.size)) {
return mLastUsedInfo;
}
for (DayAdapterInfo info : mAdapterInfos) {
if (info.offset <= position
&& position < (info.offset + info.size)) {
mLastUsedInfo = info;
return info;
}
}
}
return null;
}
private DayAdapterInfo getAdapterInfoByTime(Time time) {
if (DEBUGLOG) Log.e(TAG, "getAdapterInfoByTime " + time.toString());
Time tmpTime = new Time(time);
long timeInMillis = tmpTime.normalize(true);
int day = Time.getJulianDay(timeInMillis, tmpTime.gmtoff);
synchronized (mAdapterInfos) {
for (DayAdapterInfo info : mAdapterInfos) {
if (info.start <= day && day <= info.end) {
return info;
}
}
}
return null;
}
public EventInfo getEventByPosition(final int positionInListView) {
return getEventByPosition(positionInListView, true);
}
/**
* Return the event info for a given position in the adapter
* @param positionInListView
* @param returnEventStartDay If true, return actual event startday. Otherwise
* return agenda date-header date as the startDay.
* The two will differ for multi-day events after the first day.
* @return
*/
public EventInfo getEventByPosition(final int positionInListView,
boolean returnEventStartDay) {
if (DEBUGLOG) Log.e(TAG, "getEventByPosition " + positionInListView);
if (positionInListView < 0) {
return null;
}
final int positionInAdapter = positionInListView - OFF_BY_ONE_BUG;
DayAdapterInfo info = getAdapterInfoByPosition(positionInAdapter);
if (info == null) {
return null;
}
int cursorPosition = info.dayAdapter.getCursorPosition(positionInAdapter - info.offset);
if (cursorPosition == Integer.MIN_VALUE) {
return null;
}
boolean isDayHeader = false;
if (cursorPosition < 0) {
cursorPosition = -cursorPosition;
isDayHeader = true;
}
if (cursorPosition < info.cursor.getCount()) {
EventInfo ei = buildEventInfoFromCursor(info.cursor, cursorPosition, isDayHeader);
if (!returnEventStartDay && !isDayHeader) {
ei.startDay = info.dayAdapter.findJulianDayFromPosition(positionInAdapter -
info.offset);
}
return ei;
}
return null;
}
private EventInfo buildEventInfoFromCursor(final Cursor cursor, int cursorPosition,
boolean isDayHeader) {
if (cursorPosition == -1) {
cursor.moveToFirst();
} else {
cursor.moveToPosition(cursorPosition);
}
EventInfo event = new EventInfo();
event.begin = cursor.getLong(AgendaWindowAdapter.INDEX_BEGIN);
event.end = cursor.getLong(AgendaWindowAdapter.INDEX_END);
event.startDay = cursor.getInt(AgendaWindowAdapter.INDEX_START_DAY);
event.allDay = cursor.getInt(AgendaWindowAdapter.INDEX_ALL_DAY) != 0;
if (event.allDay) { // UTC
Time time = new Time(mTimeZone);
time.setJulianDay(Time.getJulianDay(event.begin, 0));
event.begin = time.toMillis(false /* use isDst */);
} else if (isDayHeader) { // Trim to midnight.
Time time = new Time(mTimeZone);
time.set(event.begin);
time.hour = 0;
time.minute = 0;
time.second = 0;
event.begin = time.toMillis(false /* use isDst */);
}
if (!isDayHeader) {
if (event.allDay) {
Time time = new Time(mTimeZone);
time.setJulianDay(Time.getJulianDay(event.end, 0));
event.end = time.toMillis(false /* use isDst */);
} else {
event.end = cursor.getLong(AgendaWindowAdapter.INDEX_END);
}
event.id = cursor.getLong(AgendaWindowAdapter.INDEX_EVENT_ID);
}
return event;
}
public void refresh(Time goToTime, long id, String searchQuery, boolean forced,
boolean refreshEventInfo) {
if (searchQuery != null) {
mSearchQuery = searchQuery;
}
if (DEBUGLOG) {
Log.e(TAG, this + ": refresh " + goToTime.toString() + " id " + id
+ ((searchQuery != null) ? searchQuery : "")
+ (forced ? " forced" : " not forced")
+ (refreshEventInfo ? " refresh event info" : ""));
}
int startDay = Time.getJulianDay(goToTime.toMillis(false), goToTime.gmtoff);
if (!forced && isInRange(startDay, startDay)) {
// No need to re-query
if (!mAgendaListView.isEventVisible(goToTime, id)) {
int gotoPosition = findEventPositionNearestTime(goToTime, id);
if (gotoPosition > 0) {
mAgendaListView.setSelectionFromTop(gotoPosition +
OFF_BY_ONE_BUG, mStickyHeaderSize);
if (mListViewScrollState == OnScrollListener.SCROLL_STATE_FLING) {
mAgendaListView.smoothScrollBy(0, 0);
}
if (refreshEventInfo) {
long newInstanceId = findInstanceIdFromPosition(gotoPosition);
if (newInstanceId != getSelectedInstanceId()) {
setSelectedInstanceId(newInstanceId);
new Handler().post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
Cursor tempCursor = getCursorByPosition(gotoPosition);
if (tempCursor != null) {
int tempCursorPosition = getCursorPositionByPosition(gotoPosition);
EventInfo event =
buildEventInfoFromCursor(tempCursor, tempCursorPosition,
false);
CalendarController.getInstance(mContext).sendEventRelatedEvent(
this, EventType.VIEW_EVENT, event.id, event.begin,
event.end, 0, 0, -1);
}
}
}
}
Time actualTime = new Time(mTimeZone);
if (goToTime != null) {
actualTime.set(goToTime);
} else {
actualTime.set(mAgendaListView.getFirstVisibleTime());
}
CalendarController.getInstance(mContext).sendEvent(this, EventType.UPDATE_TITLE,
actualTime, actualTime, -1, ViewType.CURRENT);
}
return;
}
// If AllInOneActivity is sending a second GOTO event(in OnResume), ignore it.
if (!mCleanQueryInitiated || searchQuery != null) {
// Query for a total of MIN_QUERY_DURATION days
int endDay = startDay + MIN_QUERY_DURATION;
mSelectedInstanceId = -1;
queueQuery(startDay, endDay, goToTime, searchQuery, QUERY_TYPE_CLEAN, id);
mCleanQueryInitiated = true;
// Pre-fetch more data to overcome a race condition in AgendaListView.shiftSelection
// Queuing more data with the goToTime set to the selected time skips the call to
// shiftSelection on refresh.
mOlderRequests++;
queueQuery(0, 0, goToTime, searchQuery, QUERY_TYPE_OLDER, id);
mNewerRequests++;
queueQuery(0, 0, goToTime, searchQuery, QUERY_TYPE_NEWER, id);
}
}
public void close() {
mShuttingDown = true;
pruneAdapterInfo(QUERY_TYPE_CLEAN);
if (mQueryHandler != null) {
mQueryHandler.cancelOperation(0);
}
}
private DayAdapterInfo pruneAdapterInfo(int queryType) {
synchronized (mAdapterInfos) {
DayAdapterInfo recycleMe = null;
if (!mAdapterInfos.isEmpty()) {
if (mAdapterInfos.size() >= MAX_NUM_OF_ADAPTERS) {
if (queryType == QUERY_TYPE_NEWER) {
recycleMe = mAdapterInfos.removeFirst();
} else if (queryType == QUERY_TYPE_OLDER) {
recycleMe = mAdapterInfos.removeLast();
// Keep the size only if the oldest items are removed.
recycleMe.size = 0;
}
if (recycleMe != null) {
if (recycleMe.cursor != null) {
recycleMe.cursor.close();
}
return recycleMe;
}
}
if (mRowCount == 0 || queryType == QUERY_TYPE_CLEAN) {
mRowCount = 0;
int deletedRows = 0;
DayAdapterInfo info;
do {
info = mAdapterInfos.poll();
if (info != null) {
// TODO the following causes ANR's. Do this in a thread.
info.cursor.close();
deletedRows += info.size;
recycleMe = info;
}
} while (info != null);
if (recycleMe != null) {
recycleMe.cursor = null;
recycleMe.size = deletedRows;
}
}
}
return recycleMe;
}
}
private String buildQuerySelection() {
// Respect the preference to show/hide declined events
if (mHideDeclined) {
return Calendars.VISIBLE + "=1 AND "
+ Instances.SELF_ATTENDEE_STATUS + "!="
+ Attendees.ATTENDEE_STATUS_DECLINED;
} else {
return Calendars.VISIBLE + "=1";
}
}
private Uri buildQueryUri(int start, int end, String searchQuery) {
Uri rootUri = searchQuery == null ?
Instances.CONTENT_BY_DAY_URI :
Instances.CONTENT_SEARCH_BY_DAY_URI;
Uri.Builder builder = rootUri.buildUpon();
ContentUris.appendId(builder, start);
ContentUris.appendId(builder, end);
if (searchQuery != null) {
builder.appendPath(searchQuery);
}
return builder.build();
}
private boolean isInRange(int start, int end) {
synchronized (mAdapterInfos) {
if (mAdapterInfos.isEmpty()) {
return false;
}
return mAdapterInfos.getFirst().start <= start && end <= mAdapterInfos.getLast().end;
}
}
private int calculateQueryDuration(int start, int end) {
int queryDuration = MAX_QUERY_DURATION;
if (mRowCount != 0) {
queryDuration = IDEAL_NUM_OF_EVENTS * (end - start + 1) / mRowCount;
}
if (queryDuration > MAX_QUERY_DURATION) {
queryDuration = MAX_QUERY_DURATION;
} else if (queryDuration < MIN_QUERY_DURATION) {
queryDuration = MIN_QUERY_DURATION;
}
return queryDuration;
}
private boolean queueQuery(int start, int end, Time goToTime,
String searchQuery, int queryType, long id) {
QuerySpec queryData = new QuerySpec(queryType);
queryData.goToTime = goToTime;
queryData.start = start;
queryData.end = end;
queryData.searchQuery = searchQuery;
queryData.id = id;
return queueQuery(queryData);
}
private boolean queueQuery(QuerySpec queryData) {
queryData.searchQuery = mSearchQuery;
Boolean queuedQuery;
synchronized (mQueryQueue) {
queuedQuery = false;
Boolean doQueryNow = mQueryQueue.isEmpty();
mQueryQueue.add(queryData);
queuedQuery = true;
if (doQueryNow) {
doQuery(queryData);
}
}
return queuedQuery;
}
private void doQuery(QuerySpec queryData) {
if (!mAdapterInfos.isEmpty()) {
int start = mAdapterInfos.getFirst().start;
int end = mAdapterInfos.getLast().end;
int queryDuration = calculateQueryDuration(start, end);
switch(queryData.queryType) {
case QUERY_TYPE_OLDER:
queryData.end = start - 1;
queryData.start = queryData.end - queryDuration;
break;
case QUERY_TYPE_NEWER:
queryData.start = end + 1;
queryData.end = queryData.start + queryDuration;
break;
}
// By "compacting" cursors, this fixes the disco/ping-pong problem
// b/5311977
if (mRowCount < 20 && queryData.queryType != QUERY_TYPE_CLEAN) {
if (DEBUGLOG) {
Log.e(TAG, "Compacting cursor: mRowCount=" + mRowCount
+ " totalStart:" + start
+ " totalEnd:" + end
+ " query.start:" + queryData.start
+ " query.end:" + queryData.end);
}
queryData.queryType = QUERY_TYPE_CLEAN;
if (queryData.start > start) {
queryData.start = start;
}
if (queryData.end < end) {
queryData.end = end;
}
}
}
if (BASICLOG) {
Time time = new Time(mTimeZone);
time.setJulianDay(queryData.start);
Time time2 = new Time(mTimeZone);
time2.setJulianDay(queryData.end);
Log.v(TAG, "startQuery: " + time.toString() + " to "
+ time2.toString() + " then go to " + queryData.goToTime);
}
mQueryHandler.cancelOperation(0);
if (BASICLOG) queryData.queryStartMillis = System.nanoTime();
Uri queryUri = buildQueryUri(
queryData.start, queryData.end, queryData.searchQuery);
mQueryHandler.startQuery(0, queryData, queryUri,
PROJECTION, buildQuerySelection(), null,
AGENDA_SORT_ORDER);
}
private String formatDateString(int julianDay) {
Time time = new Time(mTimeZone);
time.setJulianDay(julianDay);
long millis = time.toMillis(false);
mStringBuilder.setLength(0);
return DateUtils.formatDateRange(mContext, mFormatter, millis, millis,
DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_ABBREV_MONTH, mTimeZone).toString();
}
private void updateHeaderFooter(final int start, final int end) {
mHeaderView.setText(mContext.getString(R.string.show_older_events,
formatDateString(start)));
mFooterView.setText(mContext.getString(R.string.show_newer_events,
formatDateString(end)));
}
private class QueryHandler extends AsyncQueryHandler {
public QueryHandler(ContentResolver cr) {
super(cr);
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
QuerySpec data = (QuerySpec)cookie;
if (BASICLOG) {
long queryEndMillis = System.nanoTime();
Log.e(TAG, "Query time(ms): "
+ (queryEndMillis - data.queryStartMillis) / 1000000
+ " Count: " + cursor.getCount());
}
if (data.queryType == QUERY_TYPE_CLEAN) {
mCleanQueryInitiated = false;
}
if (mShuttingDown) {
cursor.close();
return;
}
// Notify Listview of changes and update position
int cursorSize = cursor.getCount();
if (cursorSize > 0 || mAdapterInfos.isEmpty() || data.queryType == QUERY_TYPE_CLEAN) {
final int listPositionOffset = processNewCursor(data, cursor);
int newPosition = -1;
if (data.goToTime == null) { // Typical Scrolling type query
notifyDataSetChanged();
if (listPositionOffset != 0) {
mAgendaListView.shiftSelection(listPositionOffset);
}
} else { // refresh() called. Go to the designated position
final Time goToTime = data.goToTime;
notifyDataSetChanged();
newPosition = findEventPositionNearestTime(goToTime, data.id);
if (newPosition >= 0) {
if (mListViewScrollState == OnScrollListener.SCROLL_STATE_FLING) {
mAgendaListView.smoothScrollBy(0, 0);
}
mAgendaListView.setSelectionFromTop(newPosition + OFF_BY_ONE_BUG,
mStickyHeaderSize);
Time actualTime = new Time(mTimeZone);
actualTime.set(goToTime);
CalendarController.getInstance(mContext).sendEvent(this,
EventType.UPDATE_TITLE, actualTime, actualTime, -1,
ViewType.CURRENT);
}
if (DEBUGLOG) {
Log.e(TAG, "Setting listview to " +
"findEventPositionNearestTime: " + (newPosition + OFF_BY_ONE_BUG));
}
}
// Make sure we change the selected instance Id only on a clean query and we
// do not have one set already
if (mSelectedInstanceId == -1 && newPosition != -1 &&
data.queryType == QUERY_TYPE_CLEAN) {
if (data.id != -1 || data.goToTime != null) {
mSelectedInstanceId = findInstanceIdFromPosition(newPosition);
}
}
// size == 1 means a fresh query. Possibly after the data changed.
// Let's check whether mSelectedInstanceId is still valid.
if (mAdapterInfos.size() == 1 && mSelectedInstanceId != -1) {
boolean found = false;
cursor.moveToPosition(-1);
while (cursor.moveToNext()) {
if (mSelectedInstanceId == cursor
.getLong(AgendaWindowAdapter.INDEX_INSTANCE_ID)) {
found = true;
break;
}
};
if (!found) {
mSelectedInstanceId = -1;
}
}
// Show the requested event
if (mShowEventOnStart && data.queryType == QUERY_TYPE_CLEAN) {
Cursor tempCursor = null;
int tempCursorPosition = -1;
// If no valid event is selected , just pick the first one
if (mSelectedInstanceId == -1) {
if (cursor.moveToFirst()) {
mSelectedInstanceId = cursor
.getLong(AgendaWindowAdapter.INDEX_INSTANCE_ID);
// Set up a dummy view holder so we have the right all day
// info when the view is created.
// TODO determine the full set of what might be useful to
// know about the selected view and fill it in.
mSelectedVH = new AgendaAdapter.ViewHolder();
mSelectedVH.allDay =
cursor.getInt(AgendaWindowAdapter.INDEX_ALL_DAY) != 0;
tempCursor = cursor;
}
} else if (newPosition != -1) {
tempCursor = getCursorByPosition(newPosition);
tempCursorPosition = getCursorPositionByPosition(newPosition);
}
if (tempCursor != null) {
EventInfo event = buildEventInfoFromCursor(tempCursor, tempCursorPosition,
false);
CalendarController.getInstance(mContext).sendEventRelatedEvent(this,
EventType.VIEW_EVENT, event.id, event.begin, event.end, 0, 0, -1);
}
}
} else {
cursor.close();
}
// Update header and footer
if (!mDoneSettingUpHeaderFooter) {
OnClickListener headerFooterOnClickListener = new OnClickListener() {
public void onClick(View v) {
if (v == mHeaderView) {
queueQuery(new QuerySpec(QUERY_TYPE_OLDER));
} else {
queueQuery(new QuerySpec(QUERY_TYPE_NEWER));
}
}};
mHeaderView.setOnClickListener(headerFooterOnClickListener);
mFooterView.setOnClickListener(headerFooterOnClickListener);
mAgendaListView.addFooterView(mFooterView);
mDoneSettingUpHeaderFooter = true;
}
synchronized (mQueryQueue) {
int totalAgendaRangeStart = -1;
int totalAgendaRangeEnd = -1;
if (cursorSize != 0) {
// Remove the query that just completed
QuerySpec x = mQueryQueue.poll();
if (BASICLOG && !x.equals(data)) {
Log.e(TAG, "onQueryComplete - cookie != head of queue");
}
mEmptyCursorCount = 0;
if (data.queryType == QUERY_TYPE_NEWER) {
mNewerRequestsProcessed++;
} else if (data.queryType == QUERY_TYPE_OLDER) {
mOlderRequestsProcessed++;
}
totalAgendaRangeStart = mAdapterInfos.getFirst().start;
totalAgendaRangeEnd = mAdapterInfos.getLast().end;
} else { // CursorSize == 0
QuerySpec querySpec = mQueryQueue.peek();
// Update Adapter Info with new start and end date range
if (!mAdapterInfos.isEmpty()) {
DayAdapterInfo first = mAdapterInfos.getFirst();
DayAdapterInfo last = mAdapterInfos.getLast();
if (first.start - 1 <= querySpec.end && querySpec.start < first.start) {
first.start = querySpec.start;
}
if (querySpec.start <= last.end + 1 && last.end < querySpec.end) {
last.end = querySpec.end;
}
totalAgendaRangeStart = first.start;
totalAgendaRangeEnd = last.end;
} else {
totalAgendaRangeStart = querySpec.start;
totalAgendaRangeEnd = querySpec.end;
}
// Update query specification with expanded search range
// and maybe rerun query
switch (querySpec.queryType) {
case QUERY_TYPE_OLDER:
totalAgendaRangeStart = querySpec.start;
querySpec.start -= MAX_QUERY_DURATION;
break;
case QUERY_TYPE_NEWER:
totalAgendaRangeEnd = querySpec.end;
querySpec.end += MAX_QUERY_DURATION;
break;
case QUERY_TYPE_CLEAN:
totalAgendaRangeStart = querySpec.start;
totalAgendaRangeEnd = querySpec.end;
querySpec.start -= MAX_QUERY_DURATION / 2;
querySpec.end += MAX_QUERY_DURATION / 2;
break;
}
if (++mEmptyCursorCount > RETRIES_ON_NO_DATA) {
// Nothing in the cursor again. Dropping query
mQueryQueue.poll();
}
}
updateHeaderFooter(totalAgendaRangeStart, totalAgendaRangeEnd);
// Go over the events and mark the first day after yesterday
// that has events in it
synchronized (mAdapterInfos) {
DayAdapterInfo info = mAdapterInfos.getFirst();
if (info != null) {
Time time = new Time(mTimeZone);
long now = System.currentTimeMillis();
time.set(now);
int JulianToday = Time.getJulianDay(now, time.gmtoff);
Iterator<DayAdapterInfo> iter = mAdapterInfos.iterator();
boolean foundDay = false;
while (iter.hasNext() && !foundDay) {
info = iter.next();
for (int i = 0; i < info.size; i++) {
if (info.dayAdapter.findJulianDayFromPosition(i) >= JulianToday) {
info.dayAdapter.setAsFirstDayAfterYesterday(i);
foundDay = true;
break;
}
}
}
}
}
// Fire off the next query if any
Iterator<QuerySpec> it = mQueryQueue.iterator();
while (it.hasNext()) {
QuerySpec queryData = it.next();
if (!isInRange(queryData.start, queryData.end)) {
// Query accepted
if (DEBUGLOG) Log.e(TAG, "Query accepted. QueueSize:" + mQueryQueue.size());
doQuery(queryData);
break;
} else {
// Query rejected
it.remove();
if (DEBUGLOG) Log.e(TAG, "Query rejected. QueueSize:" + mQueryQueue.size());
}
}
}
if (BASICLOG) {
for (DayAdapterInfo info3 : mAdapterInfos) {
Log.e(TAG, "> " + info3.toString());
}
}
}
/*
* Update the adapter info array with a the new cursor. Close out old
* cursors as needed.
*
* @return number of rows removed from the beginning
*/
private int processNewCursor(QuerySpec data, Cursor cursor) {
synchronized (mAdapterInfos) {
// Remove adapter info's from adapterInfos as needed
DayAdapterInfo info = pruneAdapterInfo(data.queryType);
int listPositionOffset = 0;
if (info == null) {
info = new DayAdapterInfo(mContext);
} else {
if (DEBUGLOG)
Log.e(TAG, "processNewCursor listPositionOffsetA="
+ -info.size);
listPositionOffset = -info.size;
}
// Setup adapter info
info.start = data.start;
info.end = data.end;
info.cursor = cursor;
info.dayAdapter.changeCursor(info);
info.size = info.dayAdapter.getCount();
// Insert into adapterInfos
if (mAdapterInfos.isEmpty()
|| data.end <= mAdapterInfos.getFirst().start) {
mAdapterInfos.addFirst(info);
listPositionOffset += info.size;
} else if (BASICLOG && data.start < mAdapterInfos.getLast().end) {
mAdapterInfos.addLast(info);
for (DayAdapterInfo info2 : mAdapterInfos) {
Log.e("========== BUG ==", info2.toString());
}
} else {
mAdapterInfos.addLast(info);
}
// Update offsets in adapterInfos
mRowCount = 0;
for (DayAdapterInfo info3 : mAdapterInfos) {
info3.offset = mRowCount;
mRowCount += info3.size;
}
mLastUsedInfo = null;
return listPositionOffset;
}
}
}
static String getViewTitle(View x) {
String title = "";
if (x != null) {
Object yy = x.getTag();
if (yy instanceof AgendaAdapter.ViewHolder) {
TextView tv = ((AgendaAdapter.ViewHolder) yy).title;
if (tv != null) {
title = (String) tv.getText();
}
} else if (yy != null) {
TextView dateView = ((AgendaByDayAdapter.ViewHolder) yy).dateView;
if (dateView != null) {
title = (String) dateView.getText();
}
}
}
return title;
}
public void onResume() {
mTZUpdater.run();
}
public void setHideDeclinedEvents(boolean hideDeclined) {
mHideDeclined = hideDeclined;
}
public void setSelectedView(View v) {
if (v != null) {
Object vh = v.getTag();
if (vh instanceof AgendaAdapter.ViewHolder) {
mSelectedVH = (AgendaAdapter.ViewHolder) vh;
mSelectedInstanceId = mSelectedVH.instanceId;
}
}
}
public AgendaAdapter.ViewHolder getSelectedViewHolder() {
return mSelectedVH;
}
public long getSelectedInstanceId() {
return mSelectedInstanceId;
}
public void setSelectedInstanceId(long selectedInstanceId) {
mSelectedInstanceId = selectedInstanceId;
mSelectedVH = null;
}
private long findInstanceIdFromPosition(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.dayAdapter.getInstanceId(position - info.offset);
}
return -1;
}
private Cursor getCursorByPosition(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.cursor;
}
return null;
}
private int getCursorPositionByPosition(int position) {
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
return info.dayAdapter.getCursorPosition(position - info.offset);
}
return -1;
}
// Implementation of HeaderIndexer interface for StickyHeeaderListView
// Returns the location of the day header of a specific event specified in the position
// in the adapter
@Override
public int getHeaderPositionFromItemPosition(int position) {
// For phone configuration, return -1 so there will be no sticky header
if (!mIsTabletConfig) {
return -1;
}
DayAdapterInfo info = getAdapterInfoByPosition(position);
if (info != null) {
int pos = info.dayAdapter.getHeaderPosition(position - info.offset);
return (pos != -1)?(pos + info.offset):-1;
}
return -1;
}
// Returns the number of events for a specific day header
@Override
public int getHeaderItemsNumber(int headerPosition) {
if (headerPosition < 0 || !mIsTabletConfig) {
return -1;
}
DayAdapterInfo info = getAdapterInfoByPosition(headerPosition);
if (info != null) {
return info.dayAdapter.getHeaderItemsCount(headerPosition - info.offset);
}
return -1;
}
@Override
public void OnHeaderHeightChanged(int height) {
mStickyHeaderSize = height;
}
public int getStickyHeaderHeight() {
return mStickyHeaderSize;
}
public void setScrollState(int state) {
mListViewScrollState = state;
}
}