| /* |
| * 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 android.accounts.Account; |
| import android.app.Activity; |
| import android.app.SearchManager; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.SharedPreferences; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.database.Cursor; |
| import android.database.MatrixCursor; |
| import android.graphics.Color; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.drawable.LayerDrawable; |
| import android.net.Uri; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.provider.CalendarContract.Calendars; |
| import android.text.Spannable; |
| import android.text.SpannableString; |
| import android.text.Spanned; |
| import android.text.TextUtils; |
| import android.text.format.DateFormat; |
| import android.text.format.DateUtils; |
| import android.text.format.Time; |
| import android.text.style.URLSpan; |
| import android.text.util.Linkify; |
| import android.util.Log; |
| |
| import com.android.calendar.CalendarController.ViewType; |
| 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.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TimeZone; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| 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 String INTENT_KEY_HOME = "KEY_HOME"; |
| |
| public static final int MONDAY_BEFORE_JULIAN_EPOCH = Time.EPOCH_JULIAN_DAY - 3; |
| public static final int DECLINED_EVENT_ALPHA = 0x66; |
| public static final int DECLINED_EVENT_TEXT_ALPHA = 0xC0; |
| |
| private static final float SATURATION_ADJUST = 1.3f; |
| private static final float INTENSITY_ADJUST = 0.8f; |
| |
| // 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; |
| |
| public static final int YEAR_MIN = 1970; |
| public static final int YEAR_MAX = 2036; |
| |
| // 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. |
| static final String SHARED_PREFS_NAME = "com.android.calendar_preferences"; |
| |
| public static final String KEY_QUICK_RESPONSES = "preferences_quick_responses"; |
| |
| public static final String KEY_ALERTS_VIBRATE_WHEN = "preferences_alerts_vibrateWhen"; |
| |
| public static final String APPWIDGET_DATA_TYPE = "vnd.android.data/update"; |
| |
| static final String MACHINE_GENERATED_ADDRESS = "calendar.google.com"; |
| |
| private static final TimeZoneUtils mTZUtils = new TimeZoneUtils(SHARED_PREFS_NAME); |
| private static boolean mAllowWeekForDetailView = false; |
| private static long mTardis = 0; |
| private static String sVersion = null; |
| |
| private static final Pattern mWildcardPattern = Pattern.compile("^.*$"); |
| |
| /** |
| * A coordinate must be of the following form for Google Maps to correctly use it: |
| * Latitude, Longitude |
| * |
| * This may be in decimal form: |
| * Latitude: {-90 to 90} |
| * Longitude: {-180 to 180} |
| * |
| * Or, in degrees, minutes, and seconds: |
| * Latitude: {-90 to 90}° {0 to 59}' {0 to 59}" |
| * Latitude: {-180 to 180}° {0 to 59}' {0 to 59}" |
| * + or - degrees may also be represented with N or n, S or s for latitude, and with |
| * E or e, W or w for longitude, where the direction may either precede or follow the value. |
| * |
| * Some examples of coordinates that will be accepted by the regex: |
| * 37.422081°, -122.084576° |
| * 37.422081,-122.084576 |
| * +37°25'19.49", -122°5'4.47" |
| * 37°25'19.49"N, 122°5'4.47"W |
| * N 37° 25' 19.49", W 122° 5' 4.47" |
| **/ |
| private static final String COORD_DEGREES_LATITUDE = |
| "([-+NnSs]" + "(\\s)*)?" |
| + "[1-9]?[0-9](\u00B0)" + "(\\s)*" |
| + "([1-5]?[0-9]\')?" + "(\\s)*" |
| + "([1-5]?[0-9]" + "(\\.[0-9]+)?\")?" |
| + "((\\s)*" + "[NnSs])?"; |
| private static final String COORD_DEGREES_LONGITUDE = |
| "([-+EeWw]" + "(\\s)*)?" |
| + "(1)?[0-9]?[0-9](\u00B0)" + "(\\s)*" |
| + "([1-5]?[0-9]\')?" + "(\\s)*" |
| + "([1-5]?[0-9]" + "(\\.[0-9]+)?\")?" |
| + "((\\s)*" + "[EeWw])?"; |
| private static final String COORD_DEGREES_PATTERN = |
| COORD_DEGREES_LATITUDE |
| + "(\\s)*" + "," + "(\\s)*" |
| + COORD_DEGREES_LONGITUDE; |
| private static final String COORD_DECIMAL_LATITUDE = |
| "[+-]?" |
| + "[1-9]?[0-9]" + "(\\.[0-9]+)" |
| + "(\u00B0)?"; |
| private static final String COORD_DECIMAL_LONGITUDE = |
| "[+-]?" |
| + "(1)?[0-9]?[0-9]" + "(\\.[0-9]+)" |
| + "(\u00B0)?"; |
| private static final String COORD_DECIMAL_PATTERN = |
| COORD_DECIMAL_LATITUDE |
| + "(\\s)*" + "," + "(\\s)*" |
| + COORD_DECIMAL_LONGITUDE; |
| private static final Pattern COORD_PATTERN = |
| Pattern.compile(COORD_DEGREES_PATTERN + "|" + COORD_DECIMAL_PATTERN); |
| |
| private static final String NANP_ALLOWED_SYMBOLS = "()+-*#."; |
| private static final int NANP_MIN_DIGITS = 7; |
| private static final int NANP_MAX_DIGITS = 11; |
| |
| |
| /** |
| * Returns whether the SDK is the Jellybean release or later. |
| */ |
| public static boolean isJellybeanOrLater() { |
| return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN; |
| } |
| |
| /** |
| * Returns whether the SDK is the KeyLimePie release or later. |
| */ |
| public static boolean isKeyLimePieOrLater() { |
| return Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT; |
| } |
| |
| 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"; |
| } |
| |
| /** |
| * 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 boolean getDefaultVibrate(Context context, SharedPreferences prefs) { |
| boolean vibrate; |
| if (prefs.contains(KEY_ALERTS_VIBRATE_WHEN)) { |
| // Migrate setting to new 4.2 behavior |
| // |
| // silent and never -> off |
| // always -> on |
| String vibrateWhen = prefs.getString(KEY_ALERTS_VIBRATE_WHEN, null); |
| vibrate = vibrateWhen != null && vibrateWhen.equals(context |
| .getString(R.string.prefDefault_alerts_vibrate_true)); |
| prefs.edit().remove(KEY_ALERTS_VIBRATE_WHEN).commit(); |
| Log.d(TAG, "Migrating KEY_ALERTS_VIBRATE_WHEN(" + vibrateWhen |
| + ") to KEY_ALERTS_VIBRATE = " + vibrate); |
| } else { |
| vibrate = prefs.getBoolean(GeneralPreferences.KEY_ALERTS_VIBRATE, |
| false); |
| } |
| return vibrate; |
| } |
| |
| public static String[] getSharedPreference(Context context, String key, String[] defaultValue) { |
| SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context); |
| Set<String> ss = prefs.getStringSet(key, null); |
| if (ss != null) { |
| String strings[] = new String[ss.size()]; |
| return ss.toArray(strings); |
| } |
| return defaultValue; |
| } |
| |
| 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(); |
| } |
| |
| public static void setSharedPreference(Context context, String key, String[] values) { |
| SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context); |
| LinkedHashSet<String> set = new LinkedHashSet<String>(); |
| for (String value : values) { |
| set.add(value); |
| } |
| prefs.edit().putStringSet(key, set).apply(); |
| } |
| |
| protected static void tardis() { |
| mTardis = System.currentTimeMillis(); |
| } |
| |
| protected static long getTardis() { |
| return mTardis; |
| } |
| |
| public 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(); |
| } |
| |
| public static void removeSharedPreference(Context context, String key) { |
| SharedPreferences prefs = context.getSharedPreferences( |
| GeneralPreferences.SHARED_PREFS_NAME, Context.MODE_PRIVATE); |
| prefs.edit().remove(key).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) { |
| if (cursor == null) { |
| return null; |
| } |
| |
| String[] columnNames = cursor.getColumnNames(); |
| if (columnNames == null) { |
| columnNames = new String[] {}; |
| } |
| MatrixCursor newCursor = new MatrixCursor(columnNames); |
| 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; |
| } |
| } |
| |
| /** |
| * Get first day of week as java.util.Calendar constant. |
| * |
| * @return the first day of week as a java.util.Calendar constant |
| */ |
| public static int getFirstDayOfWeekAsCalendar(Context context) { |
| return convertDayOfWeekFromTimeToCalendar(getFirstDayOfWeek(context)); |
| } |
| |
| /** |
| * Converts the day of the week from android.text.format.Time to java.util.Calendar |
| */ |
| public static int convertDayOfWeekFromTimeToCalendar(int timeDayOfWeek) { |
| switch (timeDayOfWeek) { |
| case Time.MONDAY: |
| return Calendar.MONDAY; |
| case Time.TUESDAY: |
| return Calendar.TUESDAY; |
| case Time.WEDNESDAY: |
| return Calendar.WEDNESDAY; |
| case Time.THURSDAY: |
| return Calendar.THURSDAY; |
| case Time.FRIDAY: |
| return Calendar.FRIDAY; |
| case Time.SATURDAY: |
| return Calendar.SATURDAY; |
| case Time.SUNDAY: |
| return Calendar.SUNDAY; |
| default: |
| throw new IllegalArgumentException("Argument must be between Time.SUNDAY and " + |
| "Time.SATURDAY"); |
| } |
| } |
| |
| /** |
| * @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); |
| } |
| |
| /** |
| * Finds and returns the next midnight after "theTime" in milliseconds UTC |
| * |
| * @param recycle - Time object to recycle, otherwise null. |
| * @param theTime - Time used for calculations (in UTC) |
| * @param tz The time zone to convert this time to. |
| */ |
| public static long getNextMidnight(Time recycle, long theTime, String tz) { |
| if (recycle == null) { |
| recycle = new Time(); |
| } |
| recycle.timezone = tz; |
| recycle.set(theTime); |
| recycle.monthDay ++; |
| recycle.hour = 0; |
| recycle.minute = 0; |
| recycle.second = 0; |
| return recycle.normalize(true); |
| } |
| |
| public static void setAllowWeekForDetailView(boolean allowWeekView) { |
| mAllowWeekForDetailView = allowWeekView; |
| } |
| |
| public static boolean getAllowWeekForDetailView() { |
| return mAllowWeekForDetailView; |
| } |
| |
| public static boolean getConfigBool(Context c, int key) { |
| return c.getResources().getBoolean(key); |
| } |
| |
| /** |
| * For devices with Jellybean or later, darkens the given color to ensure that white text is |
| * clearly visible on top of it. For devices prior to Jellybean, does nothing, as the |
| * sync adapter handles the color change. |
| * |
| * @param color |
| */ |
| public static int getDisplayColorFromColor(int color) { |
| if (!isJellybeanOrLater()) { |
| return color; |
| } |
| |
| float[] hsv = new float[3]; |
| Color.colorToHSV(color, hsv); |
| hsv[1] = Math.min(hsv[1] * SATURATION_ADJUST, 1.0f); |
| hsv[2] = hsv[2] * INTENSITY_ADJUST; |
| return Color.HSVToColor(hsv); |
| } |
| |
| // This takes a color and computes what it would look like blended with |
| // white. The result is the color that should be used for declined events. |
| public static int getDeclinedColorFromColor(int color) { |
| int bg = 0xffffffff; |
| int a = DECLINED_EVENT_ALPHA; |
| int r = (((color & 0x00ff0000) * a) + ((bg & 0x00ff0000) * (0xff - a))) & 0xff000000; |
| int g = (((color & 0x0000ff00) * a) + ((bg & 0x0000ff00) * (0xff - a))) & 0x00ff0000; |
| int b = (((color & 0x000000ff) * a) + ((bg & 0x000000ff) * (0xff - a))) & 0x0000ff00; |
| return (0xff000000) | ((r | g | b) >> 8); |
| } |
| |
| public static void trySyncAndDisableUpgradeReceiver(Context context) { |
| final PackageManager pm = context.getPackageManager(); |
| ComponentName upgradeComponent = new ComponentName(context, UpgradeReceiver.class); |
| if (pm.getComponentEnabledSetting(upgradeComponent) == |
| PackageManager.COMPONENT_ENABLED_STATE_DISABLED) { |
| // The upgrade receiver has been disabled, which means this code has been run before, |
| // so no need to sync. |
| return; |
| } |
| |
| Bundle extras = new Bundle(); |
| extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true); |
| ContentResolver.requestSync( |
| null /* no account */, |
| Calendars.CONTENT_URI.getAuthority(), |
| extras); |
| |
| // Now unregister the receiver so that we won't continue to sync every time. |
| pm.setComponentEnabledSetting(upgradeComponent, |
| PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); |
| } |
| |
| // 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(context, AllInOneActivity.class); |
| launchIntent.setAction(Intent.ACTION_DEFAULT); |
| launchIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); |
| launchIntent.putExtra(INTENT_KEY_HOME, true); |
| context.startActivity(launchIntent); |
| } |
| |
| /** |
| * Given a context and a time in millis since unix epoch figures out the |
| * correct week of the year for that time. |
| * |
| * @param millisSinceEpoch |
| * @return |
| */ |
| public static int getWeekNumberFromTime(long millisSinceEpoch, Context context) { |
| Time weekTime = new Time(getTimeZone(context, null)); |
| weekTime.set(millisSinceEpoch); |
| weekTime.normalize(true); |
| int firstDayOfWeek = getFirstDayOfWeek(context); |
| // if the date is on Saturday or Sunday and the start of the week |
| // isn't Monday we may need to shift the date to be in the correct |
| // week |
| if (weekTime.weekDay == Time.SUNDAY |
| && (firstDayOfWeek == Time.SUNDAY || firstDayOfWeek == Time.SATURDAY)) { |
| weekTime.monthDay++; |
| weekTime.normalize(true); |
| } else if (weekTime.weekDay == Time.SATURDAY && firstDayOfWeek == Time.SATURDAY) { |
| weekTime.monthDay += 2; |
| weekTime.normalize(true); |
| } |
| return weekTime.getWeekNumber(); |
| } |
| |
| /** |
| * Formats a day of the week string. This is either just the name of the day |
| * or a combination of yesterday/today/tomorrow and the day of the week. |
| * |
| * @param julianDay The julian day to get the string for |
| * @param todayJulianDay The julian day for today's date |
| * @param millis A utc millis since epoch time that falls on julian day |
| * @param context The calling context, used to get the timezone and do the |
| * formatting |
| * @return |
| */ |
| public static String getDayOfWeekString(int julianDay, int todayJulianDay, long millis, |
| Context context) { |
| getTimeZone(context, null); |
| int flags = DateUtils.FORMAT_SHOW_WEEKDAY; |
| String dayViewText; |
| if (julianDay == todayJulianDay) { |
| dayViewText = context.getString(R.string.agenda_today, |
| mTZUtils.formatDateRange(context, millis, millis, flags).toString()); |
| } else if (julianDay == todayJulianDay - 1) { |
| dayViewText = context.getString(R.string.agenda_yesterday, |
| mTZUtils.formatDateRange(context, millis, millis, flags).toString()); |
| } else if (julianDay == todayJulianDay + 1) { |
| dayViewText = context.getString(R.string.agenda_tomorrow, |
| mTZUtils.formatDateRange(context, millis, millis, flags).toString()); |
| } else { |
| dayViewText = mTZUtils.formatDateRange(context, millis, millis, flags).toString(); |
| } |
| dayViewText = dayViewText.toUpperCase(); |
| return dayViewText; |
| } |
| |
| // Calculate the time until midnight + 1 second and set the handler to |
| // do run the runnable |
| public static void setMidnightUpdater(Handler h, Runnable r, String timezone) { |
| if (h == null || r == null || timezone == null) { |
| return; |
| } |
| long now = System.currentTimeMillis(); |
| Time time = new Time(timezone); |
| time.set(now); |
| long runInMillis = (24 * 3600 - time.hour * 3600 - time.minute * 60 - |
| time.second + 1) * 1000; |
| h.removeCallbacks(r); |
| h.postDelayed(r, runInMillis); |
| } |
| |
| // Stop the midnight update thread |
| public static void resetMidnightUpdater(Handler h, Runnable r) { |
| if (h == null || r == null) { |
| return; |
| } |
| h.removeCallbacks(r); |
| } |
| |
| /** |
| * Returns a string description of the specified time interval. |
| */ |
| public static String getDisplayedDatetime(long startMillis, long endMillis, long currentMillis, |
| String localTimezone, boolean allDay, Context context) { |
| // Configure date/time formatting. |
| int flagsDate = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_WEEKDAY; |
| int flagsTime = DateUtils.FORMAT_SHOW_TIME; |
| if (DateFormat.is24HourFormat(context)) { |
| flagsTime |= DateUtils.FORMAT_24HOUR; |
| } |
| |
| Time currentTime = new Time(localTimezone); |
| currentTime.set(currentMillis); |
| Resources resources = context.getResources(); |
| String datetimeString = null; |
| if (allDay) { |
| // All day events require special timezone adjustment. |
| long localStartMillis = convertAlldayUtcToLocal(null, startMillis, localTimezone); |
| long localEndMillis = convertAlldayUtcToLocal(null, endMillis, localTimezone); |
| if (singleDayEvent(localStartMillis, localEndMillis, currentTime.gmtoff)) { |
| // If possible, use "Today" or "Tomorrow" instead of a full date string. |
| int todayOrTomorrow = isTodayOrTomorrow(context.getResources(), |
| localStartMillis, currentMillis, currentTime.gmtoff); |
| if (TODAY == todayOrTomorrow) { |
| datetimeString = resources.getString(R.string.today); |
| } else if (TOMORROW == todayOrTomorrow) { |
| datetimeString = resources.getString(R.string.tomorrow); |
| } |
| } |
| if (datetimeString == null) { |
| // For multi-day allday events or single-day all-day events that are not |
| // today or tomorrow, use framework formatter. |
| Formatter f = new Formatter(new StringBuilder(50), Locale.getDefault()); |
| datetimeString = DateUtils.formatDateRange(context, f, startMillis, |
| endMillis, flagsDate, Time.TIMEZONE_UTC).toString(); |
| } |
| } else { |
| if (singleDayEvent(startMillis, endMillis, currentTime.gmtoff)) { |
| // Format the time. |
| String timeString = Utils.formatDateRange(context, startMillis, endMillis, |
| flagsTime); |
| |
| // If possible, use "Today" or "Tomorrow" instead of a full date string. |
| int todayOrTomorrow = isTodayOrTomorrow(context.getResources(), startMillis, |
| currentMillis, currentTime.gmtoff); |
| if (TODAY == todayOrTomorrow) { |
| // Example: "Today at 1:00pm - 2:00 pm" |
| datetimeString = resources.getString(R.string.today_at_time_fmt, |
| timeString); |
| } else if (TOMORROW == todayOrTomorrow) { |
| // Example: "Tomorrow at 1:00pm - 2:00 pm" |
| datetimeString = resources.getString(R.string.tomorrow_at_time_fmt, |
| timeString); |
| } else { |
| // Format the full date. Example: "Thursday, April 12, 1:00pm - 2:00pm" |
| String dateString = Utils.formatDateRange(context, startMillis, endMillis, |
| flagsDate); |
| datetimeString = resources.getString(R.string.date_time_fmt, dateString, |
| timeString); |
| } |
| } else { |
| // For multiday events, shorten day/month names. |
| // Example format: "Fri Apr 6, 5:00pm - Sun, Apr 8, 6:00pm" |
| int flagsDatetime = flagsDate | flagsTime | DateUtils.FORMAT_ABBREV_MONTH | |
| DateUtils.FORMAT_ABBREV_WEEKDAY; |
| datetimeString = Utils.formatDateRange(context, startMillis, endMillis, |
| flagsDatetime); |
| } |
| } |
| return datetimeString; |
| } |
| |
| /** |
| * Returns the timezone to display in the event info, if the local timezone is different |
| * from the event timezone. Otherwise returns null. |
| */ |
| public static String getDisplayedTimezone(long startMillis, String localTimezone, |
| String eventTimezone) { |
| String tzDisplay = null; |
| if (!TextUtils.equals(localTimezone, eventTimezone)) { |
| // Figure out if this is in DST |
| TimeZone tz = TimeZone.getTimeZone(localTimezone); |
| if (tz == null || tz.getID().equals("GMT")) { |
| tzDisplay = localTimezone; |
| } else { |
| Time startTime = new Time(localTimezone); |
| startTime.set(startMillis); |
| tzDisplay = tz.getDisplayName(startTime.isDst != 0, TimeZone.SHORT); |
| } |
| } |
| return tzDisplay; |
| } |
| |
| /** |
| * Returns whether the specified time interval is in a single day. |
| */ |
| private static boolean singleDayEvent(long startMillis, long endMillis, long localGmtOffset) { |
| if (startMillis == endMillis) { |
| return true; |
| } |
| |
| // An event ending at midnight should still be a single-day event, so check |
| // time end-1. |
| int startDay = Time.getJulianDay(startMillis, localGmtOffset); |
| int endDay = Time.getJulianDay(endMillis - 1, localGmtOffset); |
| return startDay == endDay; |
| } |
| |
| // Using int constants as a return value instead of an enum to minimize resources. |
| private static final int TODAY = 1; |
| private static final int TOMORROW = 2; |
| private static final int NONE = 0; |
| |
| /** |
| * Returns TODAY or TOMORROW if applicable. Otherwise returns NONE. |
| */ |
| private static int isTodayOrTomorrow(Resources r, long dayMillis, |
| long currentMillis, long localGmtOffset) { |
| int startDay = Time.getJulianDay(dayMillis, localGmtOffset); |
| int currentDay = Time.getJulianDay(currentMillis, localGmtOffset); |
| |
| int days = startDay - currentDay; |
| if (days == 1) { |
| return TOMORROW; |
| } else if (days == 0) { |
| return TODAY; |
| } else { |
| return NONE; |
| } |
| } |
| |
| /** |
| * Inserts a drawable with today's day into the today's icon in the option menu |
| * @param icon - today's icon from the options menu |
| */ |
| public static void setTodayIcon(LayerDrawable icon, Context c, String timezone) { |
| DayOfMonthDrawable today; |
| |
| // Reuse current drawable if possible |
| Drawable currentDrawable = icon.findDrawableByLayerId(R.id.today_icon_day); |
| if (currentDrawable != null && currentDrawable instanceof DayOfMonthDrawable) { |
| today = (DayOfMonthDrawable)currentDrawable; |
| } else { |
| today = new DayOfMonthDrawable(c); |
| } |
| // Set the day and update the icon |
| Time now = new Time(timezone); |
| now.setToNow(); |
| now.normalize(false); |
| today.setDayOfMonth(now.monthDay); |
| icon.mutate(); |
| icon.setDrawableByLayerId(R.id.today_icon_day, today); |
| } |
| |
| /** |
| * Get a list of quick responses used for emailing guests from the |
| * SharedPreferences. If not are found, get the hard coded ones that shipped |
| * with the app |
| * |
| * @param context |
| * @return a list of quick responses. |
| */ |
| public static String[] getQuickResponses(Context context) { |
| String[] s = Utils.getSharedPreference(context, KEY_QUICK_RESPONSES, (String[]) null); |
| |
| if (s == null) { |
| s = context.getResources().getStringArray(R.array.quick_response_defaults); |
| } |
| |
| return s; |
| } |
| |
| /** |
| * Return the app version code. |
| */ |
| public static String getVersionCode(Context context) { |
| if (sVersion == null) { |
| try { |
| sVersion = context.getPackageManager().getPackageInfo( |
| context.getPackageName(), 0).versionName; |
| } catch (PackageManager.NameNotFoundException e) { |
| // Can't find version; just leave it blank. |
| Log.e(TAG, "Error finding package " + context.getApplicationInfo().packageName); |
| } |
| } |
| return sVersion; |
| } |
| } |
