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 android.widget; 18 19 import static android.text.format.DateUtils.DAY_IN_MILLIS; 20 import static android.text.format.DateUtils.HOUR_IN_MILLIS; 21 import static android.text.format.DateUtils.MINUTE_IN_MILLIS; 22 import static android.text.format.DateUtils.YEAR_IN_MILLIS; 23 import static android.text.format.Time.getJulianDay; 24 25 import android.app.ActivityThread; 26 import android.content.BroadcastReceiver; 27 import android.content.Context; 28 import android.content.Intent; 29 import android.content.IntentFilter; 30 import android.content.res.Configuration; 31 import android.content.res.TypedArray; 32 import android.database.ContentObserver; 33 import android.icu.util.Calendar; 34 import android.os.Handler; 35 import android.text.format.Time; 36 import android.util.AttributeSet; 37 import android.view.accessibility.AccessibilityNodeInfo; 38 import android.widget.RemoteViews.RemoteView; 39 40 import com.android.internal.R; 41 42 import java.text.DateFormat; 43 import java.util.ArrayList; 44 import java.util.Date; 45 import java.util.TimeZone; 46 47 // 48 // TODO 49 // - listen for the next threshold time to update the view. 50 // - listen for date format pref changed 51 // - put the AM/PM in a smaller font 52 // 53 54 /** 55 * Displays a given time in a convenient human-readable foramt. 56 * 57 * @hide 58 */ 59 @RemoteView 60 public class DateTimeView extends TextView { 61 private static final int SHOW_TIME = 0; 62 private static final int SHOW_MONTH_DAY_YEAR = 1; 63 64 Date mTime; 65 long mTimeMillis; 66 67 int mLastDisplay = -1; 68 DateFormat mLastFormat; 69 70 private long mUpdateTimeMillis; 71 private static final ThreadLocal<ReceiverInfo> sReceiverInfo = new ThreadLocal<ReceiverInfo>(); 72 private String mNowText; 73 private boolean mShowRelativeTime; 74 75 public DateTimeView(Context context) { 76 this(context, null); 77 } 78 79 public DateTimeView(Context context, AttributeSet attrs) { 80 super(context, attrs); 81 final TypedArray a = context.obtainStyledAttributes(attrs, 82 com.android.internal.R.styleable.DateTimeView, 0, 83 0); 84 85 final int N = a.getIndexCount(); 86 for (int i = 0; i < N; i++) { 87 int attr = a.getIndex(i); 88 switch (attr) { 89 case R.styleable.DateTimeView_showRelative: 90 boolean relative = a.getBoolean(i, false); 91 setShowRelativeTime(relative); 92 break; 93 } 94 } 95 a.recycle(); 96 } 97 98 @Override 99 protected void onAttachedToWindow() { 100 super.onAttachedToWindow(); 101 ReceiverInfo ri = sReceiverInfo.get(); 102 if (ri == null) { 103 ri = new ReceiverInfo(); 104 sReceiverInfo.set(ri); 105 } 106 ri.addView(this); 107 // The view may not be added to the view hierarchy immediately right after setTime() 108 // is called which means it won't get any update from intents before being added. 109 // In such case, the view might show the incorrect relative time after being added to the 110 // view hierarchy until the next update intent comes. 111 // So we update the time here if mShowRelativeTime is enabled to prevent this case. 112 if (mShowRelativeTime) { 113 update(); 114 } 115 } 116 117 @Override 118 protected void onDetachedFromWindow() { 119 super.onDetachedFromWindow(); 120 final ReceiverInfo ri = sReceiverInfo.get(); 121 if (ri != null) { 122 ri.removeView(this); 123 } 124 } 125 126 @android.view.RemotableViewMethod 127 public void setTime(long time) { 128 Time t = new Time(); 129 t.set(time); 130 mTimeMillis = t.toMillis(false); 131 mTime = new Date(t.year-1900, t.month, t.monthDay, t.hour, t.minute, 0); 132 update(); 133 } 134 135 @android.view.RemotableViewMethod 136 public void setShowRelativeTime(boolean showRelativeTime) { 137 mShowRelativeTime = showRelativeTime; 138 updateNowText(); 139 update(); 140 } 141 142 @Override 143 @android.view.RemotableViewMethod 144 public void setVisibility(@Visibility int visibility) { 145 boolean gotVisible = visibility != GONE && getVisibility() == GONE; 146 super.setVisibility(visibility); 147 if (gotVisible) { 148 update(); 149 } 150 } 151 152 void update() { 153 if (mTime == null || getVisibility() == GONE) { 154 return; 155 } 156 if (mShowRelativeTime) { 157 updateRelativeTime(); 158 return; 159 } 160 161 int display; 162 Date time = mTime; 163 164 Time t = new Time(); 165 t.set(mTimeMillis); 166 t.second = 0; 167 168 t.hour -= 12; 169 long twelveHoursBefore = t.toMillis(false); 170 t.hour += 12; 171 long twelveHoursAfter = t.toMillis(false); 172 t.hour = 0; 173 t.minute = 0; 174 long midnightBefore = t.toMillis(false); 175 t.monthDay++; 176 long midnightAfter = t.toMillis(false); 177 178 long nowMillis = System.currentTimeMillis(); 179 t.set(nowMillis); 180 t.second = 0; 181 nowMillis = t.normalize(false); 182 183 // Choose the display mode 184 choose_display: { 185 if ((nowMillis >= midnightBefore && nowMillis < midnightAfter) 186 || (nowMillis >= twelveHoursBefore && nowMillis < twelveHoursAfter)) { 187 display = SHOW_TIME; 188 break choose_display; 189 } 190 // Else, show month day and year. 191 display = SHOW_MONTH_DAY_YEAR; 192 break choose_display; 193 } 194 195 // Choose the format 196 DateFormat format; 197 if (display == mLastDisplay && mLastFormat != null) { 198 // use cached format 199 format = mLastFormat; 200 } else { 201 switch (display) { 202 case SHOW_TIME: 203 format = getTimeFormat(); 204 break; 205 case SHOW_MONTH_DAY_YEAR: 206 format = DateFormat.getDateInstance(DateFormat.SHORT); 207 break; 208 default: 209 throw new RuntimeException("unknown display value: " + display); 210 } 211 mLastFormat = format; 212 } 213 214 // Set the text 215 String text = format.format(mTime); 216 setText(text); 217 218 // Schedule the next update 219 if (display == SHOW_TIME) { 220 // Currently showing the time, update at the later of twelve hours after or midnight. 221 mUpdateTimeMillis = twelveHoursAfter > midnightAfter ? twelveHoursAfter : midnightAfter; 222 } else { 223 // Currently showing the date 224 if (mTimeMillis < nowMillis) { 225 // If the time is in the past, don't schedule an update 226 mUpdateTimeMillis = 0; 227 } else { 228 // If hte time is in the future, schedule one at the earlier of twelve hours 229 // before or midnight before. 230 mUpdateTimeMillis = twelveHoursBefore < midnightBefore 231 ? twelveHoursBefore : midnightBefore; 232 } 233 } 234 } 235 236 private void updateRelativeTime() { 237 long now = System.currentTimeMillis(); 238 long duration = Math.abs(now - mTimeMillis); 239 int count; 240 long millisIncrease; 241 boolean past = (now >= mTimeMillis); 242 String result; 243 if (duration < MINUTE_IN_MILLIS) { 244 setText(mNowText); 245 mUpdateTimeMillis = mTimeMillis + MINUTE_IN_MILLIS + 1; 246 return; 247 } else if (duration < HOUR_IN_MILLIS) { 248 count = (int)(duration / MINUTE_IN_MILLIS); 249 result = String.format(getContext().getResources().getQuantityString(past 250 ? com.android.internal.R.plurals.duration_minutes_shortest 251 : com.android.internal.R.plurals.duration_minutes_shortest_future, 252 count), 253 count); 254 millisIncrease = MINUTE_IN_MILLIS; 255 } else if (duration < DAY_IN_MILLIS) { 256 count = (int)(duration / HOUR_IN_MILLIS); 257 result = String.format(getContext().getResources().getQuantityString(past 258 ? com.android.internal.R.plurals.duration_hours_shortest 259 : com.android.internal.R.plurals.duration_hours_shortest_future, 260 count), 261 count); 262 millisIncrease = HOUR_IN_MILLIS; 263 } else if (duration < YEAR_IN_MILLIS) { 264 // In weird cases it can become 0 because of daylight savings 265 TimeZone timeZone = TimeZone.getDefault(); 266 count = Math.max(Math.abs(dayDistance(timeZone, mTimeMillis, now)), 1); 267 result = String.format(getContext().getResources().getQuantityString(past 268 ? com.android.internal.R.plurals.duration_days_shortest 269 : com.android.internal.R.plurals.duration_days_shortest_future, 270 count), 271 count); 272 if (past || count != 1) { 273 mUpdateTimeMillis = computeNextMidnight(timeZone); 274 millisIncrease = -1; 275 } else { 276 millisIncrease = DAY_IN_MILLIS; 277 } 278 279 } else { 280 count = (int)(duration / YEAR_IN_MILLIS); 281 result = String.format(getContext().getResources().getQuantityString(past 282 ? com.android.internal.R.plurals.duration_years_shortest 283 : com.android.internal.R.plurals.duration_years_shortest_future, 284 count), 285 count); 286 millisIncrease = YEAR_IN_MILLIS; 287 } 288 if (millisIncrease != -1) { 289 if (past) { 290 mUpdateTimeMillis = mTimeMillis + millisIncrease * (count + 1) + 1; 291 } else { 292 mUpdateTimeMillis = mTimeMillis - millisIncrease * count + 1; 293 } 294 } 295 setText(result); 296 } 297 298 /** 299 * @param timeZone the timezone we are in 300 * @return the timepoint in millis at UTC at midnight in the current timezone 301 */ 302 private long computeNextMidnight(TimeZone timeZone) { 303 Calendar c = Calendar.getInstance(); 304 c.setTimeZone(libcore.icu.DateUtilsBridge.icuTimeZone(timeZone)); 305 c.add(Calendar.DAY_OF_MONTH, 1); 306 c.set(Calendar.HOUR_OF_DAY, 0); 307 c.set(Calendar.MINUTE, 0); 308 c.set(Calendar.SECOND, 0); 309 c.set(Calendar.MILLISECOND, 0); 310 return c.getTimeInMillis(); 311 } 312 313 @Override 314 protected void onConfigurationChanged(Configuration newConfig) { 315 super.onConfigurationChanged(newConfig); 316 updateNowText(); 317 update(); 318 } 319 320 private void updateNowText() { 321 if (!mShowRelativeTime) { 322 return; 323 } 324 mNowText = getContext().getResources().getString( 325 com.android.internal.R.string.now_string_shortest); 326 } 327 328 // Return the date difference for the two times in a given timezone. 329 private static int dayDistance(TimeZone timeZone, long startTime, 330 long endTime) { 331 return getJulianDay(endTime, timeZone.getOffset(endTime) / 1000) 332 - getJulianDay(startTime, timeZone.getOffset(startTime) / 1000); 333 } 334 335 private DateFormat getTimeFormat() { 336 return android.text.format.DateFormat.getTimeFormat(getContext()); 337 } 338 339 void clearFormatAndUpdate() { 340 mLastFormat = null; 341 update(); 342 } 343 344 @Override 345 public void onInitializeAccessibilityNodeInfoInternal(AccessibilityNodeInfo info) { 346 super.onInitializeAccessibilityNodeInfoInternal(info); 347 if (mShowRelativeTime) { 348 // The short version of the time might not be completely understandable and for 349 // accessibility we rather have a longer version. 350 long now = System.currentTimeMillis(); 351 long duration = Math.abs(now - mTimeMillis); 352 int count; 353 boolean past = (now >= mTimeMillis); 354 String result; 355 if (duration < MINUTE_IN_MILLIS) { 356 result = mNowText; 357 } else if (duration < HOUR_IN_MILLIS) { 358 count = (int)(duration / MINUTE_IN_MILLIS); 359 result = String.format(getContext().getResources().getQuantityString(past 360 ? com.android.internal. 361 R.plurals.duration_minutes_relative 362 : com.android.internal. 363 R.plurals.duration_minutes_relative_future, 364 count), 365 count); 366 } else if (duration < DAY_IN_MILLIS) { 367 count = (int)(duration / HOUR_IN_MILLIS); 368 result = String.format(getContext().getResources().getQuantityString(past 369 ? com.android.internal. 370 R.plurals.duration_hours_relative 371 : com.android.internal. 372 R.plurals.duration_hours_relative_future, 373 count), 374 count); 375 } else if (duration < YEAR_IN_MILLIS) { 376 // In weird cases it can become 0 because of daylight savings 377 TimeZone timeZone = TimeZone.getDefault(); 378 count = Math.max(Math.abs(dayDistance(timeZone, mTimeMillis, now)), 1); 379 result = String.format(getContext().getResources().getQuantityString(past 380 ? com.android.internal. 381 R.plurals.duration_days_relative 382 : com.android.internal. 383 R.plurals.duration_days_relative_future, 384 count), 385 count); 386 387 } else { 388 count = (int)(duration / YEAR_IN_MILLIS); 389 result = String.format(getContext().getResources().getQuantityString(past 390 ? com.android.internal. 391 R.plurals.duration_years_relative 392 : com.android.internal. 393 R.plurals.duration_years_relative_future, 394 count), 395 count); 396 } 397 info.setText(result); 398 } 399 } 400 401 /** 402 * @hide 403 */ 404 public static void setReceiverHandler(Handler handler) { 405 ReceiverInfo ri = sReceiverInfo.get(); 406 if (ri == null) { 407 ri = new ReceiverInfo(); 408 sReceiverInfo.set(ri); 409 } 410 ri.setHandler(handler); 411 } 412 413 private static class ReceiverInfo { 414 private final ArrayList<DateTimeView> mAttachedViews = new ArrayList<DateTimeView>(); 415 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 416 @Override 417 public void onReceive(Context context, Intent intent) { 418 String action = intent.getAction(); 419 if (Intent.ACTION_TIME_TICK.equals(action)) { 420 if (System.currentTimeMillis() < getSoonestUpdateTime()) { 421 // The update() function takes a few milliseconds to run because of 422 // all of the time conversions it needs to do, so we can't do that 423 // every minute. 424 return; 425 } 426 } 427 // ACTION_TIME_CHANGED can also signal a change of 12/24 hr. format. 428 updateAll(); 429 } 430 }; 431 432 private final ContentObserver mObserver = new ContentObserver(new Handler()) { 433 @Override 434 public void onChange(boolean selfChange) { 435 updateAll(); 436 } 437 }; 438 439 private Handler mHandler = new Handler(); 440 441 public void addView(DateTimeView v) { 442 synchronized (mAttachedViews) { 443 final boolean register = mAttachedViews.isEmpty(); 444 mAttachedViews.add(v); 445 if (register) { 446 register(getApplicationContextIfAvailable(v.getContext())); 447 } 448 } 449 } 450 451 public void removeView(DateTimeView v) { 452 synchronized (mAttachedViews) { 453 final boolean removed = mAttachedViews.remove(v); 454 // Only unregister once when we remove the last view in the list otherwise we risk 455 // trying to unregister a receiver that is no longer registered. 456 if (removed && mAttachedViews.isEmpty()) { 457 unregister(getApplicationContextIfAvailable(v.getContext())); 458 } 459 } 460 } 461 462 void updateAll() { 463 synchronized (mAttachedViews) { 464 final int count = mAttachedViews.size(); 465 for (int i = 0; i < count; i++) { 466 DateTimeView view = mAttachedViews.get(i); 467 view.post(() -> view.clearFormatAndUpdate()); 468 } 469 } 470 } 471 472 long getSoonestUpdateTime() { 473 long result = Long.MAX_VALUE; 474 synchronized (mAttachedViews) { 475 final int count = mAttachedViews.size(); 476 for (int i = 0; i < count; i++) { 477 final long time = mAttachedViews.get(i).mUpdateTimeMillis; 478 if (time < result) { 479 result = time; 480 } 481 } 482 } 483 return result; 484 } 485 486 static final Context getApplicationContextIfAvailable(Context context) { 487 final Context ac = context.getApplicationContext(); 488 return ac != null ? ac : ActivityThread.currentApplication().getApplicationContext(); 489 } 490 491 void register(Context context) { 492 final IntentFilter filter = new IntentFilter(); 493 filter.addAction(Intent.ACTION_TIME_TICK); 494 filter.addAction(Intent.ACTION_TIME_CHANGED); 495 filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED); 496 filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); 497 context.registerReceiver(mReceiver, filter, null, mHandler); 498 } 499 500 void unregister(Context context) { 501 context.unregisterReceiver(mReceiver); 502 } 503 504 public void setHandler(Handler handler) { 505 mHandler = handler; 506 synchronized (mAttachedViews) { 507 if (!mAttachedViews.isEmpty()) { 508 unregister(mAttachedViews.get(0).getContext()); 509 register(mAttachedViews.get(0).getContext()); 510 } 511 } 512 } 513 } 514 } 515