/*
* Copyright (C) 2006 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;
import static android.provider.CalendarContract.EXTRA_EVENT_BEGIN_TIME;
import com.android.calendar.CalendarController.ViewType;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.text.format.Time;
import android.util.Log;
import com.android.calendar.CalendarUtils.TimeZoneUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class Utils {
private static final boolean DEBUG = false;
private static final String TAG = "CalUtils";
// Set to 0 until we have UI to perform undo
public static final long UNDO_DELAY = 0;
// For recurring events which instances of the series are being modified
public static final int MODIFY_UNINITIALIZED = 0;
public static final int MODIFY_SELECTED = 1;
public static final int MODIFY_ALL_FOLLOWING = 2;
public static final int MODIFY_ALL = 3;
// When the edit event view finishes it passes back the appropriate exit
// code.
public static final int DONE_REVERT = 1 << 0;
public static final int DONE_SAVE = 1 << 1;
public static final int DONE_DELETE = 1 << 2;
// And should re run with DONE_EXIT if it should also leave the view, just
// exiting is identical to reverting
public static final int DONE_EXIT = 1 << 0;
public static final String OPEN_EMAIL_MARKER = " <";
public static final String CLOSE_EMAIL_MARKER = ">";
public static final String INTENT_KEY_DETAIL_VIEW = "DETAIL_VIEW";
public static final String INTENT_KEY_VIEW_TYPE = "VIEW";
public static final String INTENT_VALUE_VIEW_TYPE_DAY = "DAY";
public static final int MONDAY_BEFORE_JULIAN_EPOCH = Time.EPOCH_JULIAN_DAY - 3;
// Defines used by the DNA generation code
static final int DAY_IN_MINUTES = 60 * 24;
static final int WEEK_IN_MINUTES = DAY_IN_MINUTES * 7;
// The work day is being counted as 6am to 8pm
static int WORK_DAY_MINUTES = 14 * 60;
static int WORK_DAY_START_MINUTES = 6 * 60;
static int WORK_DAY_END_MINUTES = 20 * 60;
static int WORK_DAY_END_LENGTH = (24 * 60) - WORK_DAY_END_MINUTES;
static int CONFLICT_COLOR = 0xFF000000;
static boolean mMinutesLoaded = false;
// The name of the shared preferences file. This name must be maintained for
// historical
// reasons, as it's what PreferenceManager assigned the first time the file
// was created.
private static final String SHARED_PREFS_NAME = "com.android.calendar_preferences";
public static final String APPWIDGET_DATA_TYPE = "vnd.android.data/update";
private static final TimeZoneUtils mTZUtils = new TimeZoneUtils(SHARED_PREFS_NAME);
private static boolean mAllowWeekForDetailView = false;
private static long mTardis = 0;
public static int getViewTypeFromIntentAndSharedPref(Activity activity) {
Intent intent = activity.getIntent();
Bundle extras = intent.getExtras();
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(activity);
if (TextUtils.equals(intent.getAction(), Intent.ACTION_EDIT)) {
return ViewType.EDIT;
}
if (extras != null) {
if (extras.getBoolean(INTENT_KEY_DETAIL_VIEW, false)) {
// This is the "detail" view which is either agenda or day view
return prefs.getInt(GeneralPreferences.KEY_DETAILED_VIEW,
GeneralPreferences.DEFAULT_DETAILED_VIEW);
} else if (INTENT_VALUE_VIEW_TYPE_DAY.equals(extras.getString(INTENT_KEY_VIEW_TYPE))) {
// Not sure who uses this. This logic came from LaunchActivity
return ViewType.DAY;
}
}
// Default to the last view
return prefs.getInt(
GeneralPreferences.KEY_START_VIEW, GeneralPreferences.DEFAULT_START_VIEW);
}
/**
* Gets the intent action for telling the widget to update.
*/
public static String getWidgetUpdateAction(Context context) {
return context.getPackageName() + ".APPWIDGET_UPDATE";
}
/**
* Gets the intent action for telling the widget to update.
*/
public static String getWidgetScheduledUpdateAction(Context context) {
return context.getPackageName() + ".APPWIDGET_SCHEDULED_UPDATE";
}
/**
* Gets the intent action for telling the widget to update.
*/
public static String getSearchAuthority(Context context) {
return context.getPackageName() + ".CalendarRecentSuggestionsProvider";
}
/**
* Writes a new home time zone to the db. Updates the home time zone in the
* db asynchronously and updates the local cache. Sending a time zone of
* **tbd** will cause it to be set to the device's time zone. null or empty
* tz will be ignored.
*
* @param context The calling activity
* @param timeZone The time zone to set Calendar to, or **tbd**
*/
public static void setTimeZone(Context context, String timeZone) {
mTZUtils.setTimeZone(context, timeZone);
}
/**
* Gets the time zone that Calendar should be displayed in This is a helper
* method to get the appropriate time zone for Calendar. If this is the
* first time this method has been called it will initiate an asynchronous
* query to verify that the data in preferences is correct. The callback
* supplied will only be called if this query returns a value other than
* what is stored in preferences and should cause the calling activity to
* refresh anything that depends on calling this method.
*
* @param context The calling activity
* @param callback The runnable that should execute if a query returns new
* values
* @return The string value representing the time zone Calendar should
* display
*/
public static String getTimeZone(Context context, Runnable callback) {
return mTZUtils.getTimeZone(context, callback);
}
/**
* Formats a date or a time range according to the local conventions.
*
* @param context the context is required only if the time is shown
* @param startMillis the start time in UTC milliseconds
* @param endMillis the end time in UTC milliseconds
* @param flags a bit mask of options See {@link DateUtils#formatDateRange(Context, Formatter,
* long, long, int, String) formatDateRange}
* @return a string containing the formatted date/time range.
*/
public static String formatDateRange(
Context context, long startMillis, long endMillis, int flags) {
return mTZUtils.formatDateRange(context, startMillis, endMillis, flags);
}
public static String getSharedPreference(Context context, String key, String defaultValue) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getString(key, defaultValue);
}
public static int getSharedPreference(Context context, String key, int defaultValue) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getInt(key, defaultValue);
}
public static boolean getSharedPreference(Context context, String key, boolean defaultValue) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getBoolean(key, defaultValue);
}
/**
* Asynchronously sets the preference with the given key to the given value
*
* @param context the context to use to get preferences from
* @param key the key of the preference to set
* @param value the value to set
*/
public static void setSharedPreference(Context context, String key, String value) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
prefs.edit().putString(key, value).apply();
}
protected static void tardis() {
mTardis = System.currentTimeMillis();
}
protected static long getTardis() {
return mTardis;
}
static void setSharedPreference(Context context, String key, boolean value) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
SharedPreferences.Editor editor = prefs.edit();
editor.putBoolean(key, value);
editor.apply();
}
static void setSharedPreference(Context context, String key, int value) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
SharedPreferences.Editor editor = prefs.edit();
editor.putInt(key, value);
editor.apply();
}
/**
* Save default agenda/day/week/month view for next time
*
* @param context
* @param viewId {@link CalendarController.ViewType}
*/
static void setDefaultView(Context context, int viewId) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
SharedPreferences.Editor editor = prefs.edit();
boolean validDetailView = false;
if (mAllowWeekForDetailView && viewId == CalendarController.ViewType.WEEK) {
validDetailView = true;
} else {
validDetailView = viewId == CalendarController.ViewType.AGENDA
|| viewId == CalendarController.ViewType.DAY;
}
if (validDetailView) {
// Record the detail start view
editor.putInt(GeneralPreferences.KEY_DETAILED_VIEW, viewId);
}
// Record the (new) start view
editor.putInt(GeneralPreferences.KEY_START_VIEW, viewId);
editor.apply();
}
public static MatrixCursor matrixCursorFromCursor(Cursor cursor) {
MatrixCursor newCursor = new MatrixCursor(cursor.getColumnNames());
int numColumns = cursor.getColumnCount();
String data[] = new String[numColumns];
cursor.moveToPosition(-1);
while (cursor.moveToNext()) {
for (int i = 0; i < numColumns; i++) {
data[i] = cursor.getString(i);
}
newCursor.addRow(data);
}
return newCursor;
}
/**
* Compares two cursors to see if they contain the same data.
*
* @return Returns true of the cursors contain the same data and are not
* null, false otherwise
*/
public static boolean compareCursors(Cursor c1, Cursor c2) {
if (c1 == null || c2 == null) {
return false;
}
int numColumns = c1.getColumnCount();
if (numColumns != c2.getColumnCount()) {
return false;
}
if (c1.getCount() != c2.getCount()) {
return false;
}
c1.moveToPosition(-1);
c2.moveToPosition(-1);
while (c1.moveToNext() && c2.moveToNext()) {
for (int i = 0; i < numColumns; i++) {
if (!TextUtils.equals(c1.getString(i), c2.getString(i))) {
return false;
}
}
}
return true;
}
/**
* If the given intent specifies a time (in milliseconds since the epoch),
* then that time is returned. Otherwise, the current time is returned.
*/
public static final long timeFromIntentInMillis(Intent intent) {
// If the time was specified, then use that. Otherwise, use the current
// time.
Uri data = intent.getData();
long millis = intent.getLongExtra(EXTRA_EVENT_BEGIN_TIME, -1);
if (millis == -1 && data != null && data.isHierarchical()) {
List<String> path = data.getPathSegments();
if (path.size() == 2 && path.get(0).equals("time")) {
try {
millis = Long.valueOf(data.getLastPathSegment());
} catch (NumberFormatException e) {
Log.i("Calendar", "timeFromIntentInMillis: Data existed but no valid time "
+ "found. Using current time.");
}
}
}
if (millis <= 0) {
millis = System.currentTimeMillis();
}
return millis;
}
/**
* Formats the given Time object so that it gives the month and year (for
* example, "September 2007").
*
* @param time the time to format
* @return the string containing the weekday and the date
*/
public static String formatMonthYear(Context context, Time time) {
int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_NO_MONTH_DAY
| DateUtils.FORMAT_SHOW_YEAR;
long millis = time.toMillis(true);
return formatDateRange(context, millis, millis, flags);
}
/**
* Returns a list joined together by the provided delimiter, for example,
* ["a", "b", "c"] could be joined into "a,b,c"
*
* @param things the things to join together
* @param delim the delimiter to use
* @return a string contained the things joined together
*/
public static String join(List<?> things, String delim) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (Object thing : things) {
if (first) {
first = false;
} else {
builder.append(delim);
}
builder.append(thing.toString());
}
return builder.toString();
}
/**
* Returns the week since {@link Time#EPOCH_JULIAN_DAY} (Jan 1, 1970)
* adjusted for first day of week.
*
* This takes a julian day and the week start day and calculates which
* week since {@link Time#EPOCH_JULIAN_DAY} that day occurs in, starting
* at 0. *Do not* use this to compute the ISO week number for the year.
*
* @param julianDay The julian day to calculate the week number for
* @param firstDayOfWeek Which week day is the first day of the week,
* see {@link Time#SUNDAY}
* @return Weeks since the epoch
*/
public static int getWeeksSinceEpochFromJulianDay(int julianDay, int firstDayOfWeek) {
int diff = Time.THURSDAY - firstDayOfWeek;
if (diff < 0) {
diff += 7;
}
int refDay = Time.EPOCH_JULIAN_DAY - diff;
return (julianDay - refDay) / 7;
}
/**
* Takes a number of weeks since the epoch and calculates the Julian day of
* the Monday for that week.
*
* This assumes that the week containing the {@link Time#EPOCH_JULIAN_DAY}
* is considered week 0. It returns the Julian day for the Monday
* {@code week} weeks after the Monday of the week containing the epoch.
*
* @param week Number of weeks since the epoch
* @return The julian day for the Monday of the given week since the epoch
*/
public static int getJulianMondayFromWeeksSinceEpoch(int week) {
return MONDAY_BEFORE_JULIAN_EPOCH + week * 7;
}
/**
* Get first day of week as android.text.format.Time constant.
*
* @return the first day of week in android.text.format.Time
*/
public static int getFirstDayOfWeek(Context context) {
SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
String pref = prefs.getString(
GeneralPreferences.KEY_WEEK_START_DAY, GeneralPreferences.WEEK_START_DEFAULT);
int startDay;
if (GeneralPreferences.WEEK_START_DEFAULT.equals(pref)) {
startDay = Calendar.getInstance().getFirstDayOfWeek();
} else {
startDay = Integer.parseInt(pref);
}
if (startDay == Calendar.SATURDAY) {
return Time.SATURDAY;
} else if (startDay == Calendar.MONDAY) {
return Time.MONDAY;
} else {
return Time.SUNDAY;
}
}
/**
* @return true when week number should be shown.
*/
public static boolean getShowWeekNumber(Context context) {
final SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getBoolean(
GeneralPreferences.KEY_SHOW_WEEK_NUM, GeneralPreferences.DEFAULT_SHOW_WEEK_NUM);
}
/**
* @return true when declined events should be hidden.
*/
public static boolean getHideDeclinedEvents(Context context) {
final SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getBoolean(GeneralPreferences.KEY_HIDE_DECLINED, false);
}
public static int getDaysPerWeek(Context context) {
final SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context);
return prefs.getInt(GeneralPreferences.KEY_DAYS_PER_WEEK, 7);
}
/**
* Determine whether the column position is Saturday or not.
*
* @param column the column position
* @param firstDayOfWeek the first day of week in android.text.format.Time
* @return true if the column is Saturday position
*/
public static boolean isSaturday(int column, int firstDayOfWeek) {
return (firstDayOfWeek == Time.SUNDAY && column == 6)
|| (firstDayOfWeek == Time.MONDAY && column == 5)
|| (firstDayOfWeek == Time.SATURDAY && column == 0);
}
/**
* Determine whether the column position is Sunday or not.
*
* @param column the column position
* @param firstDayOfWeek the first day of week in android.text.format.Time
* @return true if the column is Sunday position
*/
public static boolean isSunday(int column, int firstDayOfWeek) {
return (firstDayOfWeek == Time.SUNDAY && column == 0)
|| (firstDayOfWeek == Time.MONDAY && column == 6)
|| (firstDayOfWeek == Time.SATURDAY && column == 1);
}
/**
* Convert given UTC time into current local time. This assumes it is for an
* allday event and will adjust the time to be on a midnight boundary.
*
* @param recycle Time object to recycle, otherwise null.
* @param utcTime Time to convert, in UTC.
* @param tz The time zone to convert this time to.
*/
public static long convertAlldayUtcToLocal(Time recycle, long utcTime, String tz) {
if (recycle == null) {
recycle = new Time();
}
recycle.timezone = Time.TIMEZONE_UTC;
recycle.set(utcTime);
recycle.timezone = tz;
return recycle.normalize(true);
}
public static long convertAlldayLocalToUTC(Time recycle, long localTime, String tz) {
if (recycle == null) {
recycle = new Time();
}
recycle.timezone = tz;
recycle.set(localTime);
recycle.timezone = Time.TIMEZONE_UTC;
return recycle.normalize(true);
}
/**
* Scan through a cursor of calendars and check if names are duplicated.
* This travels a cursor containing calendar display names and fills in the
* provided map with whether or not each name is repeated.
*
* @param isDuplicateName The map to put the duplicate check results in.
* @param cursor The query of calendars to check
* @param nameIndex The column of the query that contains the display name
*/
public static void checkForDuplicateNames(
Map<String, Boolean> isDuplicateName, Cursor cursor, int nameIndex) {
isDuplicateName.clear();
cursor.moveToPosition(-1);
while (cursor.moveToNext()) {
String displayName = cursor.getString(nameIndex);
// Set it to true if we've seen this name before, false otherwise
if (displayName != null) {
isDuplicateName.put(displayName, isDuplicateName.containsKey(displayName));
}
}
}
/**
* Null-safe object comparison
*
* @param s1
* @param s2
* @return
*/
public static boolean equals(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
public static void setAllowWeekForDetailView(boolean allowWeekView) {
mAllowWeekForDetailView = allowWeekView;
}
public static boolean getAllowWeekForDetailView() {
return mAllowWeekForDetailView;
}
public static boolean isMultiPaneConfiguration (Context c) {
return (c.getResources().getConfiguration().screenLayout &
Configuration.SCREENLAYOUT_SIZE_XLARGE) != 0;
}
public static boolean getConfigBool(Context c, int key) {
return c.getResources().getBoolean(key);
}
// A single strand represents one color of events. Events are divided up by
// color to make them convenient to draw. The black strand is special in
// that it holds conflicting events as well as color settings for allday on
// each day.
public static class DNAStrand {
public float[] points;
public int[] allDays; // color for the allday, 0 means no event
int position;
public int color;
int count;
}
// A segment is a single continuous length of time occupied by a single
// color. Segments should never span multiple days.
private static class DNASegment {
int startMinute; // in minutes since the start of the week
int endMinute;
int color; // Calendar color or black for conflicts
int day; // quick reference to the day this segment is on
}
/**
* Converts a list of events to a list of segments to draw. Assumes list is
* ordered by start time of the events. The function processes events for a
* range of days from firstJulianDay to firstJulianDay + dayXs.length - 1.
* The algorithm goes over all the events and creates a set of segments
* ordered by start time. This list of segments is then converted into a
* HashMap of strands which contain the draw points and are organized by
* color. The strands can then be drawn by setting the paint color to each
* strand's color and calling drawLines on its set of points. The points are
* set up using the following parameters.
* <ul>
* <li>Events between midnight and WORK_DAY_START_MINUTES are compressed
* into the first 1/8th of the space between top and bottom.</li>
* <li>Events between WORK_DAY_END_MINUTES and the following midnight are
* compressed into the last 1/8th of the space between top and bottom</li>
* <li>Events between WORK_DAY_START_MINUTES and WORK_DAY_END_MINUTES use
* the remaining 3/4ths of the space</li>
* <li>All segments drawn will maintain at least minPixels height, except
* for conflicts in the first or last 1/8th, which may be smaller</li>
* </ul>
*
* @param firstJulianDay The julian day of the first day of events
* @param events A list of events sorted by start time
* @param top The lowest y value the dna should be drawn at
* @param bottom The highest y value the dna should be drawn at
* @param dayXs An array of x values to draw the dna at, one for each day
* @param conflictColor the color to use for conflicts
* @return
*/
public static HashMap<Integer, DNAStrand> createDNAStrands(int firstJulianDay,
ArrayList<Event> events, int top, int bottom, int minPixels, int[] dayXs,
Context context) {
if (!mMinutesLoaded) {
if (context == null) {
Log.wtf(TAG, "No context and haven't loaded parameters yet! Can't create DNA.");
}
Resources res = context.getResources();
CONFLICT_COLOR = res.getColor(R.color.month_dna_conflict_time_color);
WORK_DAY_START_MINUTES = res.getInteger(R.integer.work_start_minutes);
WORK_DAY_END_MINUTES = res.getInteger(R.integer.work_end_minutes);
WORK_DAY_END_LENGTH = DAY_IN_MINUTES - WORK_DAY_END_MINUTES;
WORK_DAY_MINUTES = WORK_DAY_END_MINUTES - WORK_DAY_START_MINUTES;
mMinutesLoaded = true;
}
if (events == null || events.isEmpty() || dayXs == null || dayXs.length < 1
|| bottom - top < 8 || minPixels < 0) {
Log.e(TAG,
"Bad values for createDNAStrands! events:" + events + " dayXs:"
+ Arrays.toString(dayXs) + " bot-top:" + (bottom - top) + " minPixels:"
+ minPixels);
return null;
}
LinkedList<DNASegment> segments = new LinkedList<DNASegment>();
HashMap<Integer, DNAStrand> strands = new HashMap<Integer, DNAStrand>();
// add a black strand by default, other colors will get added in
// the loop
DNAStrand blackStrand = new DNAStrand();
blackStrand.color = CONFLICT_COLOR;
strands.put(CONFLICT_COLOR, blackStrand);
// the min length is the number of minutes that will occupy
// MIN_SEGMENT_PIXELS in the 'work day' time slot. This computes the
// minutes/pixel * minpx where the number of pixels are 3/4 the total
// dna height: 4*(mins/(px * 3/4))
int minMinutes = minPixels * 4 * WORK_DAY_MINUTES / (3 * (bottom - top));
// There are slightly fewer than half as many pixels in 1/6 the space,
// so round to 2.5x for the min minutes in the non-work area
int minOtherMinutes = minMinutes * 5 / 2;
int lastJulianDay = firstJulianDay + dayXs.length - 1;
Event event = new Event();
// Go through all the events for the week
for (Event currEvent : events) {
// if this event is outside the weeks range skip it
if (currEvent.endDay < firstJulianDay || currEvent.startDay > lastJulianDay) {
continue;
}
if (currEvent.drawAsAllday()) {
addAllDayToStrands(currEvent, strands, firstJulianDay, dayXs.length);
continue;
}
// Copy the event over so we can clip its start and end to our range
currEvent.copyTo(event);
if (event.startDay < firstJulianDay) {
event.startDay = firstJulianDay;
event.startTime = 0;
}
// If it starts after the work day make sure the start is at least
// minPixels from midnight
if (event.startTime > DAY_IN_MINUTES - minOtherMinutes) {
event.startTime = DAY_IN_MINUTES - minOtherMinutes;
}
if (event.endDay > lastJulianDay) {
event.endDay = lastJulianDay;
event.endTime = DAY_IN_MINUTES - 1;
}
// If the end time is before the work day make sure it ends at least
// minPixels after midnight
if (event.endTime < minOtherMinutes) {
event.endTime = minOtherMinutes;
}
// If the start and end are on the same day make sure they are at
// least minPixels apart. This only needs to be done for times
// outside the work day as the min distance for within the work day
// is enforced in the segment code.
if (event.startDay == event.endDay &&
event.endTime - event.startTime < minOtherMinutes) {
// If it's less than minPixels in an area before the work
// day
if (event.startTime < WORK_DAY_START_MINUTES) {
// extend the end to the first easy guarantee that it's
// minPixels
event.endTime = Math.min(event.startTime + minOtherMinutes,
WORK_DAY_START_MINUTES + minMinutes);
// if it's in the area after the work day
} else if (event.endTime > WORK_DAY_END_MINUTES) {
// First try shifting the end but not past midnight
event.endTime = Math.min(event.endTime + minOtherMinutes, DAY_IN_MINUTES - 1);
// if it's still too small move the start back
if (event.endTime - event.startTime < minOtherMinutes) {
event.startTime = event.endTime - minOtherMinutes;
}
}
}
// This handles adding the first segment
if (segments.size() == 0) {
addNewSegment(segments, event, strands, firstJulianDay, 0, minMinutes);
continue;
}
// Now compare our current start time to the end time of the last
// segment in the list
DNASegment lastSegment = segments.getLast();
int startMinute = (event.startDay - firstJulianDay) * DAY_IN_MINUTES + event.startTime;
int endMinute = Math.max((event.endDay - firstJulianDay) * DAY_IN_MINUTES
+ event.endTime, startMinute + minMinutes);
if (startMinute < 0) {
startMinute = 0;
}
if (endMinute >= WEEK_IN_MINUTES) {
endMinute = WEEK_IN_MINUTES - 1;
}
// If we start before the last segment in the list ends we need to
// start going through the list as this may conflict with other
// events
if (startMinute < lastSegment.endMinute) {
int i = segments.size();
// find the last segment this event intersects with
while (--i >= 0 && endMinute < segments.get(i).startMinute);
DNASegment currSegment;
// for each segment this event intersects with
for (; i >= 0 && startMinute <= (currSegment = segments.get(i)).endMinute; i--) {
// if the segment is already a conflict ignore it
if (currSegment.color == CONFLICT_COLOR) {
continue;
}
// if the event ends before the segment and wouldn't create
// a segment that is too small split off the right side
if (endMinute < currSegment.endMinute - minMinutes) {
DNASegment rhs = new DNASegment();
rhs.endMinute = currSegment.endMinute;
rhs.color = currSegment.color;
rhs.startMinute = endMinute + 1;
rhs.day = currSegment.day;
currSegment.endMinute = endMinute;
segments.add(i + 1, rhs);
strands.get(rhs.color).count++;
if (DEBUG) {
Log.d(TAG, "Added rhs, curr:" + currSegment.toString() + " i:"
+ segments.get(i).toString());
}
}
// if the event starts after the segment and wouldn't create
// a segment that is too small split off the left side
if (startMinute > currSegment.startMinute + minMinutes) {
DNASegment lhs = new DNASegment();
lhs.startMinute = currSegment.startMinute;
lhs.color = currSegment.color;
lhs.endMinute = startMinute - 1;
lhs.day = currSegment.day;
currSegment.startMinute = startMinute;
// increment i so that we are at the right position when
// referencing the segments to the right and left of the
// current segment.
segments.add(i++, lhs);
strands.get(lhs.color).count++;
if (DEBUG) {
Log.d(TAG, "Added lhs, curr:" + currSegment.toString() + " i:"
+ segments.get(i).toString());
}
}
// if the right side is black merge this with the segment to
// the right if they're on the same day and overlap
if (i + 1 < segments.size()) {
DNASegment rhs = segments.get(i + 1);
if (rhs.color == CONFLICT_COLOR && currSegment.day == rhs.day
&& rhs.startMinute <= currSegment.endMinute + 1) {
rhs.startMinute = Math.min(currSegment.startMinute, rhs.startMinute);
segments.remove(currSegment);
strands.get(currSegment.color).count--;
// point at the new current segment
currSegment = rhs;
}
}
// if the left side is black merge this with the segment to
// the left if they're on the same day and overlap
if (i - 1 >= 0) {
DNASegment lhs = segments.get(i - 1);
if (lhs.color == CONFLICT_COLOR && currSegment.day == lhs.day
&& lhs.endMinute >= currSegment.startMinute - 1) {
lhs.endMinute = Math.max(currSegment.endMinute, lhs.endMinute);
segments.remove(currSegment);
strands.get(currSegment.color).count--;
// point at the new current segment
currSegment = lhs;
// point i at the new current segment in case new
// code is added
i--;
}
}
// if we're still not black, decrement the count for the
// color being removed, change this to black, and increment
// the black count
if (currSegment.color != CONFLICT_COLOR) {
strands.get(currSegment.color).count--;
currSegment.color = CONFLICT_COLOR;
strands.get(CONFLICT_COLOR).count++;
}
}
}
// If this event extends beyond the last segment add a new segment
if (endMinute > lastSegment.endMinute) {
addNewSegment(segments, event, strands, firstJulianDay, lastSegment.endMinute,
minMinutes);
}
}
weaveDNAStrands(segments, firstJulianDay, strands, top, bottom, dayXs);
return strands;
}
// This figures out allDay colors as allDay events are found
private static void addAllDayToStrands(Event event, HashMap<Integer, DNAStrand> strands,
int firstJulianDay, int numDays) {
DNAStrand strand = getOrCreateStrand(strands, CONFLICT_COLOR);
// if we haven't initialized the allDay portion create it now
if (strand.allDays == null) {
strand.allDays = new int[numDays];
}
// For each day this event is on update the color
int end = Math.min(event.endDay - firstJulianDay, numDays - 1);
for (int i = Math.max(event.startDay - firstJulianDay, 0); i <= end; i++) {
if (strand.allDays[i] != 0) {
// if this day already had a color, it is now a conflict
strand.allDays[i] = CONFLICT_COLOR;
} else {
// else it's just the color of the event
strand.allDays[i] = event.color;
}
}
}
// This processes all the segments, sorts them by color, and generates a
// list of points to draw
private static void weaveDNAStrands(LinkedList<DNASegment> segments, int firstJulianDay,
HashMap<Integer, DNAStrand> strands, int top, int bottom, int[] dayXs) {
// First, get rid of any colors that ended up with no segments
Iterator<DNAStrand> strandIterator = strands.values().iterator();
while (strandIterator.hasNext()) {
DNAStrand strand = strandIterator.next();
if (strand.count < 1 && strand.allDays == null) {
strandIterator.remove();
continue;
}
strand.points = new float[strand.count * 4];
strand.position = 0;
}
// Go through each segment and compute its points
for (DNASegment segment : segments) {
// Add the points to the strand of that color
DNAStrand strand = strands.get(segment.color);
int dayIndex = segment.day - firstJulianDay;
int dayStartMinute = segment.startMinute % DAY_IN_MINUTES;
int dayEndMinute = segment.endMinute % DAY_IN_MINUTES;
int height = bottom - top;
int workDayHeight = height * 3 / 4;
int remainderHeight = (height - workDayHeight) / 2;
int x = dayXs[dayIndex];
int y0 = 0;
int y1 = 0;
y0 = top + getPixelOffsetFromMinutes(dayStartMinute, workDayHeight, remainderHeight);
y1 = top + getPixelOffsetFromMinutes(dayEndMinute, workDayHeight, remainderHeight);
if (DEBUG) {
Log.d(TAG, "Adding " + Integer.toHexString(segment.color) + " at x,y0,y1: " + x
+ " " + y0 + " " + y1 + " for " + dayStartMinute + " " + dayEndMinute);
}
strand.points[strand.position++] = x;
strand.points[strand.position++] = y0;
strand.points[strand.position++] = x;
strand.points[strand.position++] = y1;
}
}
/**
* Compute a pixel offset from the top for a given minute from the work day
* height and the height of the top area.
*/
private static int getPixelOffsetFromMinutes(int minute, int workDayHeight,
int remainderHeight) {
int y;
if (minute < WORK_DAY_START_MINUTES) {
y = minute * remainderHeight / WORK_DAY_START_MINUTES;
} else if (minute < WORK_DAY_END_MINUTES) {
y = remainderHeight + (minute - WORK_DAY_START_MINUTES) * workDayHeight
/ WORK_DAY_MINUTES;
} else {
y = remainderHeight + workDayHeight + (minute - WORK_DAY_END_MINUTES) * remainderHeight
/ WORK_DAY_END_LENGTH;
}
return y;
}
/**
* Add a new segment based on the event provided. This will handle splitting
* segments across day boundaries and ensures a minimum size for segments.
*/
private static void addNewSegment(LinkedList<DNASegment> segments, Event event,
HashMap<Integer, DNAStrand> strands, int firstJulianDay, int minStart, int minMinutes) {
if (event.startDay > event.endDay) {
Log.wtf(TAG, "Event starts after it ends: " + event.toString());
}
// If this is a multiday event split it up by day
if (event.startDay != event.endDay) {
Event lhs = new Event();
lhs.color = event.color;
lhs.startDay = event.startDay;
// the first day we want the start time to be the actual start time
lhs.startTime = event.startTime;
lhs.endDay = lhs.startDay;
lhs.endTime = DAY_IN_MINUTES - 1;
// Nearly recursive iteration!
while (lhs.startDay != event.endDay) {
addNewSegment(segments, lhs, strands, firstJulianDay, minStart, minMinutes);
// The days in between are all day, even though that shouldn't
// actually happen due to the allday filtering
lhs.startDay++;
lhs.endDay = lhs.startDay;
lhs.startTime = 0;
minStart = 0;
}
// The last day we want the end time to be the actual end time
lhs.endTime = event.endTime;
event = lhs;
}
// Create the new segment and compute its fields
DNASegment segment = new DNASegment();
int dayOffset = (event.startDay - firstJulianDay) * DAY_IN_MINUTES;
int endOfDay = dayOffset + DAY_IN_MINUTES - 1;
// clip the start if needed
segment.startMinute = Math.max(dayOffset + event.startTime, minStart);
// and extend the end if it's too small, but not beyond the end of the
// day
int minEnd = Math.min(segment.startMinute + minMinutes, endOfDay);
segment.endMinute = Math.max(dayOffset + event.endTime, minEnd);
if (segment.endMinute > endOfDay) {
segment.endMinute = endOfDay;
}
segment.color = event.color;
segment.day = event.startDay;
segments.add(segment);
// increment the count for the correct color or add a new strand if we
// don't have that color yet
DNAStrand strand = getOrCreateStrand(strands, segment.color);
strand.count++;
}
/**
* Try to get a strand of the given color. Create it if it doesn't exist.
*/
private static DNAStrand getOrCreateStrand(HashMap<Integer, DNAStrand> strands, int color) {
DNAStrand strand = strands.get(color);
if (strand == null) {
strand = new DNAStrand();
strand.color = color;
strand.count = 0;
strands.put(strand.color, strand);
}
return strand;
}
/**
* Sends an intent to launch the top level Calendar view.
*
* @param context
*/
public static void returnToCalendarHome(Context context) {
Intent launchIntent = new Intent();
launchIntent.setAction(Intent.ACTION_VIEW);
launchIntent.setData(Uri.parse("content://com.android.calendar/time"));
launchIntent.setClass(context, AllInOneActivity.class);
launchIntent.setFlags(
Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED | Intent.FLAG_ACTIVITY_CLEAR_TOP);
context.startActivity(launchIntent);
}
}