1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.contacts.common.util; 18 19 import android.content.Context; 20 import android.text.format.DateFormat; 21 import android.text.format.Time; 22 23 24 import java.text.ParsePosition; 25 import java.text.SimpleDateFormat; 26 import java.util.Calendar; 27 import java.util.Date; 28 import java.util.GregorianCalendar; 29 import java.util.Locale; 30 import java.util.TimeZone; 31 32 /** 33 * Utility methods for processing dates. 34 */ 35 public class DateUtils { 36 public static final TimeZone UTC_TIMEZONE = TimeZone.getTimeZone("UTC"); 37 38 /** 39 * When parsing a date without a year, the system assumes 1970, which wasn't a leap-year. 40 * Let's add a one-off hack for that day of the year 41 */ 42 public static final String NO_YEAR_DATE_FEB29TH = "--02-29"; 43 44 // Variations of ISO 8601 date format. Do not change the order - it does affect the 45 // result in ambiguous cases. 46 private static final SimpleDateFormat[] DATE_FORMATS = { 47 CommonDateUtils.FULL_DATE_FORMAT, 48 CommonDateUtils.DATE_AND_TIME_FORMAT, 49 new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'", Locale.US), 50 new SimpleDateFormat("yyyyMMdd", Locale.US), 51 new SimpleDateFormat("yyyyMMdd'T'HHmmssSSS'Z'", Locale.US), 52 new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'", Locale.US), 53 new SimpleDateFormat("yyyyMMdd'T'HHmm'Z'", Locale.US), 54 }; 55 56 static { 57 for (SimpleDateFormat format : DATE_FORMATS) { 58 format.setLenient(true); 59 format.setTimeZone(UTC_TIMEZONE); 60 } 61 CommonDateUtils.NO_YEAR_DATE_FORMAT.setTimeZone(UTC_TIMEZONE); 62 } 63 64 /** 65 * Parses the supplied string to see if it looks like a date. 66 * 67 * @param string The string representation of the provided date 68 * @param mustContainYear If true, the string is parsed as a date containing a year. If false, 69 * the string is parsed into a valid date even if the year field is missing. 70 * @return A Calendar object corresponding to the date if the string is successfully parsed. 71 * If not, null is returned. 72 */ 73 public static Calendar parseDate(String string, boolean mustContainYear) { 74 ParsePosition parsePosition = new ParsePosition(0); 75 Date date; 76 if (!mustContainYear) { 77 final boolean noYearParsed; 78 // Unfortunately, we can't parse Feb 29th correctly, so let's handle this day seperately 79 if (NO_YEAR_DATE_FEB29TH.equals(string)) { 80 return getUtcDate(0, Calendar.FEBRUARY, 29); 81 } else { 82 synchronized (CommonDateUtils.NO_YEAR_DATE_FORMAT) { 83 date = CommonDateUtils.NO_YEAR_DATE_FORMAT.parse(string, parsePosition); 84 } 85 noYearParsed = parsePosition.getIndex() == string.length(); 86 } 87 88 if (noYearParsed) { 89 return getUtcDate(date, true); 90 } 91 } 92 for (int i = 0; i < DATE_FORMATS.length; i++) { 93 SimpleDateFormat f = DATE_FORMATS[i]; 94 synchronized (f) { 95 parsePosition.setIndex(0); 96 date = f.parse(string, parsePosition); 97 if (parsePosition.getIndex() == string.length()) { 98 return getUtcDate(date, false); 99 } 100 } 101 } 102 return null; 103 } 104 105 private static final Calendar getUtcDate(Date date, boolean noYear) { 106 final Calendar calendar = Calendar.getInstance(UTC_TIMEZONE, Locale.US); 107 calendar.setTime(date); 108 if (noYear) { 109 calendar.set(Calendar.YEAR, 0); 110 } 111 return calendar; 112 } 113 114 private static final Calendar getUtcDate(int year, int month, int dayOfMonth) { 115 final Calendar calendar = Calendar.getInstance(UTC_TIMEZONE, Locale.US); 116 calendar.clear(); 117 calendar.set(Calendar.YEAR, year); 118 calendar.set(Calendar.MONTH, month); 119 calendar.set(Calendar.DAY_OF_MONTH, dayOfMonth); 120 return calendar; 121 } 122 123 public static boolean isYearSet(Calendar cal) { 124 // use the Calendar.YEAR field to track whether or not the year is set instead of 125 // Calendar.isSet() because doing Calendar.get() causes Calendar.isSet() to become 126 // true irregardless of what the previous value was 127 return cal.get(Calendar.YEAR) > 1; 128 } 129 130 /** 131 * Same as {@link #formatDate(Context context, String string, boolean longForm)}, with 132 * longForm set to {@code true} by default. 133 * 134 * @param context Valid context 135 * @param string String representation of a date to parse 136 * @return Returns the same date in a cleaned up format. If the supplied string does not look 137 * like a date, return it unchanged. 138 */ 139 140 public static String formatDate(Context context, String string) { 141 return formatDate(context, string, true); 142 } 143 144 /** 145 * Parses the supplied string to see if it looks like a date. 146 * 147 * @param context Valid context 148 * @param string String representation of a date to parse 149 * @param longForm If true, return the date formatted into its long string representation. 150 * If false, return the date formatted using its short form representation (i.e. 12/11/2012) 151 * @return Returns the same date in a cleaned up format. If the supplied string does not look 152 * like a date, return it unchanged. 153 */ 154 public static String formatDate(Context context, String string, boolean longForm) { 155 if (string == null) { 156 return null; 157 } 158 159 string = string.trim(); 160 if (string.length() == 0) { 161 return string; 162 } 163 final Calendar cal = parseDate(string, false); 164 165 // we weren't able to parse the string successfully so just return it unchanged 166 if (cal == null) { 167 return string; 168 } 169 170 final boolean isYearSet = isYearSet(cal); 171 final java.text.DateFormat outFormat; 172 if (!isYearSet) { 173 outFormat = getLocalizedDateFormatWithoutYear(context); 174 } else { 175 outFormat = 176 longForm ? DateFormat.getLongDateFormat(context) : 177 DateFormat.getDateFormat(context); 178 } 179 synchronized (outFormat) { 180 outFormat.setTimeZone(UTC_TIMEZONE); 181 return outFormat.format(cal.getTime()); 182 } 183 } 184 185 public static boolean isMonthBeforeDay(Context context) { 186 char[] dateFormatOrder = DateFormat.getDateFormatOrder(context); 187 for (int i = 0; i < dateFormatOrder.length; i++) { 188 if (dateFormatOrder[i] == DateFormat.DATE) { 189 return false; 190 } 191 if (dateFormatOrder[i] == DateFormat.MONTH) { 192 return true; 193 } 194 } 195 return false; 196 } 197 198 /** 199 * Returns a SimpleDateFormat object without the year fields by using a regular expression 200 * to eliminate the year in the string pattern. In the rare occurence that the resulting 201 * pattern cannot be reconverted into a SimpleDateFormat, it uses the provided context to 202 * determine whether the month field should be displayed before the day field, and returns 203 * either "MMMM dd" or "dd MMMM" converted into a SimpleDateFormat. 204 */ 205 public static java.text.DateFormat getLocalizedDateFormatWithoutYear(Context context) { 206 final String pattern = ((SimpleDateFormat) SimpleDateFormat.getDateInstance( 207 java.text.DateFormat.LONG)).toPattern(); 208 // Determine the correct regex pattern for year. 209 // Special case handling for Spanish locale by checking for "de" 210 final String yearPattern = pattern.contains( 211 "de") ? "[^Mm]*[Yy]+[^Mm]*" : "[^DdMm]*[Yy]+[^DdMm]*"; 212 try { 213 // Eliminate the substring in pattern that matches the format for that of year 214 return new SimpleDateFormat(pattern.replaceAll(yearPattern, "")); 215 } catch (IllegalArgumentException e) { 216 return new SimpleDateFormat( 217 DateUtils.isMonthBeforeDay(context) ? "MMMM dd" : "dd MMMM"); 218 } 219 } 220 221 /** 222 * Given a calendar (possibly containing only a day of the year), returns the earliest possible 223 * anniversary of the date that is equal to or after the current point in time if the date 224 * does not contain a year, or the date converted to the local time zone (if the date contains 225 * a year. 226 * 227 * @param target The date we wish to convert(in the UTC time zone). 228 * @return If date does not contain a year (year < 1900), returns the next earliest anniversary 229 * that is after the current point in time (in the local time zone). Otherwise, returns the 230 * adjusted Date in the local time zone. 231 */ 232 public static Date getNextAnnualDate(Calendar target) { 233 final Calendar today = Calendar.getInstance(); 234 today.setTime(new Date()); 235 236 // Round the current time to the exact start of today so that when we compare 237 // today against the target date, both dates are set to exactly 0000H. 238 today.set(Calendar.HOUR_OF_DAY, 0); 239 today.set(Calendar.MINUTE, 0); 240 today.set(Calendar.SECOND, 0); 241 today.set(Calendar.MILLISECOND, 0); 242 243 final boolean isYearSet = isYearSet(target); 244 final int targetYear = target.get(Calendar.YEAR); 245 final int targetMonth = target.get(Calendar.MONTH); 246 final int targetDay = target.get(Calendar.DAY_OF_MONTH); 247 final boolean isFeb29 = (targetMonth == Calendar.FEBRUARY && targetDay == 29); 248 final GregorianCalendar anniversary = new GregorianCalendar(); 249 // Convert from the UTC date to the local date. Set the year to today's year if the 250 // there is no provided year (targetYear < 1900) 251 anniversary.set(!isYearSet ? today.get(Calendar.YEAR) : targetYear, 252 targetMonth, targetDay); 253 // If the anniversary's date is before the start of today and there is no year set, 254 // increment the year by 1 so that the returned date is always equal to or greater than 255 // today. If the day is a leap year, keep going until we get the next leap year anniversary 256 // Otherwise if there is already a year set, simply return the exact date. 257 if (!isYearSet) { 258 int anniversaryYear = today.get(Calendar.YEAR); 259 if (anniversary.before(today) || 260 (isFeb29 && !anniversary.isLeapYear(anniversaryYear))) { 261 // If the target date is not Feb 29, then set the anniversary to the next year. 262 // Otherwise, keep going until we find the next leap year (this is not guaranteed 263 // to be in 4 years time). 264 do { 265 anniversaryYear +=1; 266 } while (isFeb29 && !anniversary.isLeapYear(anniversaryYear)); 267 anniversary.set(anniversaryYear, targetMonth, targetDay); 268 } 269 } 270 return anniversary.getTime(); 271 } 272 273 /** 274 * Determine the difference, in days between two dates. Uses similar logic as the 275 * {@link android.text.format.DateUtils.getRelativeTimeSpanString} method. 276 * 277 * @param time Instance of time object to use for calculations. 278 * @param date1 First date to check. 279 * @param date2 Second date to check. 280 * @return The absolute difference in days between the two dates. 281 */ 282 public static int getDayDifference(Time time, long date1, long date2) { 283 time.set(date1); 284 int startDay = Time.getJulianDay(date1, time.gmtoff); 285 286 time.set(date2); 287 int currentDay = Time.getJulianDay(date2, time.gmtoff); 288 289 return Math.abs(currentDay - startDay); 290 } 291 } 292
