1 /* 2 * Copyright (C) 2014 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.example.android.wearable.watchface; 18 19 import android.content.BroadcastReceiver; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.content.IntentFilter; 23 import android.content.res.Resources; 24 import android.graphics.Canvas; 25 import android.graphics.Paint; 26 import android.graphics.Rect; 27 import android.graphics.Typeface; 28 import android.os.Bundle; 29 import android.os.Handler; 30 import android.os.Message; 31 import android.support.wearable.watchface.CanvasWatchFaceService; 32 import android.support.wearable.watchface.WatchFaceService; 33 import android.support.wearable.watchface.WatchFaceStyle; 34 import android.text.format.DateFormat; 35 import android.util.Log; 36 import android.view.SurfaceHolder; 37 import android.view.WindowInsets; 38 39 import com.google.android.gms.common.ConnectionResult; 40 import com.google.android.gms.common.api.GoogleApiClient; 41 import com.google.android.gms.wearable.DataApi; 42 import com.google.android.gms.wearable.DataEvent; 43 import com.google.android.gms.wearable.DataEventBuffer; 44 import com.google.android.gms.wearable.DataItem; 45 import com.google.android.gms.wearable.DataMap; 46 import com.google.android.gms.wearable.DataMapItem; 47 import com.google.android.gms.wearable.Wearable; 48 49 import java.text.SimpleDateFormat; 50 import java.util.Calendar; 51 import java.util.Date; 52 import java.util.Locale; 53 import java.util.TimeZone; 54 import java.util.concurrent.TimeUnit; 55 56 /** 57 * Sample digital watch face with blinking colons and seconds. In ambient mode, the seconds are 58 * replaced with an AM/PM indicator and the colons don't blink. On devices with low-bit ambient 59 * mode, the text is drawn without anti-aliasing in ambient mode. On devices which require burn-in 60 * protection, the hours are drawn in normal rather than bold. The time is drawn with less contrast 61 * and without seconds in mute mode. 62 */ 63 public class DigitalWatchFaceService extends CanvasWatchFaceService { 64 private static final String TAG = "DigitalWatchFaceService"; 65 66 private static final Typeface BOLD_TYPEFACE = 67 Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD); 68 private static final Typeface NORMAL_TYPEFACE = 69 Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL); 70 71 /** 72 * Update rate in milliseconds for normal (not ambient and not mute) mode. We update twice 73 * a second to blink the colons. 74 */ 75 private static final long NORMAL_UPDATE_RATE_MS = 500; 76 77 /** 78 * Update rate in milliseconds for mute mode. We update every minute, like in ambient mode. 79 */ 80 private static final long MUTE_UPDATE_RATE_MS = TimeUnit.MINUTES.toMillis(1); 81 82 @Override 83 public Engine onCreateEngine() { 84 return new Engine(); 85 } 86 87 private class Engine extends CanvasWatchFaceService.Engine implements DataApi.DataListener, 88 GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener { 89 static final String COLON_STRING = ":"; 90 91 /** Alpha value for drawing time when in mute mode. */ 92 static final int MUTE_ALPHA = 100; 93 94 /** Alpha value for drawing time when not in mute mode. */ 95 static final int NORMAL_ALPHA = 255; 96 97 static final int MSG_UPDATE_TIME = 0; 98 99 /** How often {@link #mUpdateTimeHandler} ticks in milliseconds. */ 100 long mInteractiveUpdateRateMs = NORMAL_UPDATE_RATE_MS; 101 102 /** Handler to update the time periodically in interactive mode. */ 103 final Handler mUpdateTimeHandler = new Handler() { 104 @Override 105 public void handleMessage(Message message) { 106 switch (message.what) { 107 case MSG_UPDATE_TIME: 108 if (Log.isLoggable(TAG, Log.VERBOSE)) { 109 Log.v(TAG, "updating time"); 110 } 111 invalidate(); 112 if (shouldTimerBeRunning()) { 113 long timeMs = System.currentTimeMillis(); 114 long delayMs = 115 mInteractiveUpdateRateMs - (timeMs % mInteractiveUpdateRateMs); 116 mUpdateTimeHandler.sendEmptyMessageDelayed(MSG_UPDATE_TIME, delayMs); 117 } 118 break; 119 } 120 } 121 }; 122 123 GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(DigitalWatchFaceService.this) 124 .addConnectionCallbacks(this) 125 .addOnConnectionFailedListener(this) 126 .addApi(Wearable.API) 127 .build(); 128 129 /** 130 * Handles time zone and locale changes. 131 */ 132 final BroadcastReceiver mReceiver = new BroadcastReceiver() { 133 @Override 134 public void onReceive(Context context, Intent intent) { 135 mCalendar.setTimeZone(TimeZone.getDefault()); 136 initFormats(); 137 invalidate(); 138 } 139 }; 140 141 /** 142 * Unregistering an unregistered receiver throws an exception. Keep track of the 143 * registration state to prevent that. 144 */ 145 boolean mRegisteredReceiver = false; 146 147 Paint mBackgroundPaint; 148 Paint mDatePaint; 149 Paint mHourPaint; 150 Paint mMinutePaint; 151 Paint mSecondPaint; 152 Paint mAmPmPaint; 153 Paint mColonPaint; 154 float mColonWidth; 155 boolean mMute; 156 157 Calendar mCalendar; 158 Date mDate; 159 SimpleDateFormat mDayOfWeekFormat; 160 java.text.DateFormat mDateFormat; 161 162 boolean mShouldDrawColons; 163 float mXOffset; 164 float mYOffset; 165 float mLineHeight; 166 String mAmString; 167 String mPmString; 168 int mInteractiveBackgroundColor = 169 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_BACKGROUND; 170 int mInteractiveHourDigitsColor = 171 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_HOUR_DIGITS; 172 int mInteractiveMinuteDigitsColor = 173 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_MINUTE_DIGITS; 174 int mInteractiveSecondDigitsColor = 175 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_SECOND_DIGITS; 176 177 /** 178 * Whether the display supports fewer bits for each color in ambient mode. When true, we 179 * disable anti-aliasing in ambient mode. 180 */ 181 boolean mLowBitAmbient; 182 183 @Override 184 public void onCreate(SurfaceHolder holder) { 185 if (Log.isLoggable(TAG, Log.DEBUG)) { 186 Log.d(TAG, "onCreate"); 187 } 188 super.onCreate(holder); 189 190 setWatchFaceStyle(new WatchFaceStyle.Builder(DigitalWatchFaceService.this) 191 .setCardPeekMode(WatchFaceStyle.PEEK_MODE_VARIABLE) 192 .setBackgroundVisibility(WatchFaceStyle.BACKGROUND_VISIBILITY_INTERRUPTIVE) 193 .setShowSystemUiTime(false) 194 .build()); 195 Resources resources = DigitalWatchFaceService.this.getResources(); 196 mYOffset = resources.getDimension(R.dimen.digital_y_offset); 197 mLineHeight = resources.getDimension(R.dimen.digital_line_height); 198 mAmString = resources.getString(R.string.digital_am); 199 mPmString = resources.getString(R.string.digital_pm); 200 201 mBackgroundPaint = new Paint(); 202 mBackgroundPaint.setColor(mInteractiveBackgroundColor); 203 mDatePaint = createTextPaint(resources.getColor(R.color.digital_date)); 204 mHourPaint = createTextPaint(mInteractiveHourDigitsColor, BOLD_TYPEFACE); 205 mMinutePaint = createTextPaint(mInteractiveMinuteDigitsColor); 206 mSecondPaint = createTextPaint(mInteractiveSecondDigitsColor); 207 mAmPmPaint = createTextPaint(resources.getColor(R.color.digital_am_pm)); 208 mColonPaint = createTextPaint(resources.getColor(R.color.digital_colons)); 209 210 mCalendar = Calendar.getInstance(); 211 mDate = new Date(); 212 initFormats(); 213 } 214 215 @Override 216 public void onDestroy() { 217 mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME); 218 super.onDestroy(); 219 } 220 221 private Paint createTextPaint(int defaultInteractiveColor) { 222 return createTextPaint(defaultInteractiveColor, NORMAL_TYPEFACE); 223 } 224 225 private Paint createTextPaint(int defaultInteractiveColor, Typeface typeface) { 226 Paint paint = new Paint(); 227 paint.setColor(defaultInteractiveColor); 228 paint.setTypeface(typeface); 229 paint.setAntiAlias(true); 230 return paint; 231 } 232 233 @Override 234 public void onVisibilityChanged(boolean visible) { 235 if (Log.isLoggable(TAG, Log.DEBUG)) { 236 Log.d(TAG, "onVisibilityChanged: " + visible); 237 } 238 super.onVisibilityChanged(visible); 239 240 if (visible) { 241 mGoogleApiClient.connect(); 242 243 registerReceiver(); 244 245 // Update time zone and date formats, in case they changed while we weren't visible. 246 mCalendar.setTimeZone(TimeZone.getDefault()); 247 initFormats(); 248 } else { 249 unregisterReceiver(); 250 251 if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) { 252 Wearable.DataApi.removeListener(mGoogleApiClient, this); 253 mGoogleApiClient.disconnect(); 254 } 255 } 256 257 // Whether the timer should be running depends on whether we're visible (as well as 258 // whether we're in ambient mode), so we may need to start or stop the timer. 259 updateTimer(); 260 } 261 262 private void initFormats() { 263 mDayOfWeekFormat = new SimpleDateFormat("EEEE", Locale.getDefault()); 264 mDayOfWeekFormat.setCalendar(mCalendar); 265 mDateFormat = DateFormat.getDateFormat(DigitalWatchFaceService.this); 266 mDateFormat.setCalendar(mCalendar); 267 } 268 269 private void registerReceiver() { 270 if (mRegisteredReceiver) { 271 return; 272 } 273 mRegisteredReceiver = true; 274 IntentFilter filter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED); 275 filter.addAction(Intent.ACTION_LOCALE_CHANGED); 276 DigitalWatchFaceService.this.registerReceiver(mReceiver, filter); 277 } 278 279 private void unregisterReceiver() { 280 if (!mRegisteredReceiver) { 281 return; 282 } 283 mRegisteredReceiver = false; 284 DigitalWatchFaceService.this.unregisterReceiver(mReceiver); 285 } 286 287 @Override 288 public void onApplyWindowInsets(WindowInsets insets) { 289 if (Log.isLoggable(TAG, Log.DEBUG)) { 290 Log.d(TAG, "onApplyWindowInsets: " + (insets.isRound() ? "round" : "square")); 291 } 292 super.onApplyWindowInsets(insets); 293 294 // Load resources that have alternate values for round watches. 295 Resources resources = DigitalWatchFaceService.this.getResources(); 296 boolean isRound = insets.isRound(); 297 mXOffset = resources.getDimension(isRound 298 ? R.dimen.digital_x_offset_round : R.dimen.digital_x_offset); 299 float textSize = resources.getDimension(isRound 300 ? R.dimen.digital_text_size_round : R.dimen.digital_text_size); 301 float amPmSize = resources.getDimension(isRound 302 ? R.dimen.digital_am_pm_size_round : R.dimen.digital_am_pm_size); 303 304 mDatePaint.setTextSize(resources.getDimension(R.dimen.digital_date_text_size)); 305 mHourPaint.setTextSize(textSize); 306 mMinutePaint.setTextSize(textSize); 307 mSecondPaint.setTextSize(textSize); 308 mAmPmPaint.setTextSize(amPmSize); 309 mColonPaint.setTextSize(textSize); 310 311 mColonWidth = mColonPaint.measureText(COLON_STRING); 312 } 313 314 @Override 315 public void onPropertiesChanged(Bundle properties) { 316 super.onPropertiesChanged(properties); 317 318 boolean burnInProtection = properties.getBoolean(PROPERTY_BURN_IN_PROTECTION, false); 319 mHourPaint.setTypeface(burnInProtection ? NORMAL_TYPEFACE : BOLD_TYPEFACE); 320 321 mLowBitAmbient = properties.getBoolean(PROPERTY_LOW_BIT_AMBIENT, false); 322 323 if (Log.isLoggable(TAG, Log.DEBUG)) { 324 Log.d(TAG, "onPropertiesChanged: burn-in protection = " + burnInProtection 325 + ", low-bit ambient = " + mLowBitAmbient); 326 } 327 } 328 329 @Override 330 public void onTimeTick() { 331 super.onTimeTick(); 332 if (Log.isLoggable(TAG, Log.DEBUG)) { 333 Log.d(TAG, "onTimeTick: ambient = " + isInAmbientMode()); 334 } 335 invalidate(); 336 } 337 338 @Override 339 public void onAmbientModeChanged(boolean inAmbientMode) { 340 super.onAmbientModeChanged(inAmbientMode); 341 if (Log.isLoggable(TAG, Log.DEBUG)) { 342 Log.d(TAG, "onAmbientModeChanged: " + inAmbientMode); 343 } 344 adjustPaintColorToCurrentMode(mBackgroundPaint, mInteractiveBackgroundColor, 345 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_BACKGROUND); 346 adjustPaintColorToCurrentMode(mHourPaint, mInteractiveHourDigitsColor, 347 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_HOUR_DIGITS); 348 adjustPaintColorToCurrentMode(mMinutePaint, mInteractiveMinuteDigitsColor, 349 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_MINUTE_DIGITS); 350 // Actually, the seconds are not rendered in the ambient mode, so we could pass just any 351 // value as ambientColor here. 352 adjustPaintColorToCurrentMode(mSecondPaint, mInteractiveSecondDigitsColor, 353 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_SECOND_DIGITS); 354 355 if (mLowBitAmbient) { 356 boolean antiAlias = !inAmbientMode; 357 mDatePaint.setAntiAlias(antiAlias); 358 mHourPaint.setAntiAlias(antiAlias); 359 mMinutePaint.setAntiAlias(antiAlias); 360 mSecondPaint.setAntiAlias(antiAlias); 361 mAmPmPaint.setAntiAlias(antiAlias); 362 mColonPaint.setAntiAlias(antiAlias); 363 } 364 invalidate(); 365 366 // Whether the timer should be running depends on whether we're in ambient mode (as well 367 // as whether we're visible), so we may need to start or stop the timer. 368 updateTimer(); 369 } 370 371 private void adjustPaintColorToCurrentMode(Paint paint, int interactiveColor, 372 int ambientColor) { 373 paint.setColor(isInAmbientMode() ? ambientColor : interactiveColor); 374 } 375 376 @Override 377 public void onInterruptionFilterChanged(int interruptionFilter) { 378 if (Log.isLoggable(TAG, Log.DEBUG)) { 379 Log.d(TAG, "onInterruptionFilterChanged: " + interruptionFilter); 380 } 381 super.onInterruptionFilterChanged(interruptionFilter); 382 383 boolean inMuteMode = interruptionFilter == WatchFaceService.INTERRUPTION_FILTER_NONE; 384 // We only need to update once a minute in mute mode. 385 setInteractiveUpdateRateMs(inMuteMode ? MUTE_UPDATE_RATE_MS : NORMAL_UPDATE_RATE_MS); 386 387 if (mMute != inMuteMode) { 388 mMute = inMuteMode; 389 int alpha = inMuteMode ? MUTE_ALPHA : NORMAL_ALPHA; 390 mDatePaint.setAlpha(alpha); 391 mHourPaint.setAlpha(alpha); 392 mMinutePaint.setAlpha(alpha); 393 mColonPaint.setAlpha(alpha); 394 mAmPmPaint.setAlpha(alpha); 395 invalidate(); 396 } 397 } 398 399 public void setInteractiveUpdateRateMs(long updateRateMs) { 400 if (updateRateMs == mInteractiveUpdateRateMs) { 401 return; 402 } 403 mInteractiveUpdateRateMs = updateRateMs; 404 405 // Stop and restart the timer so the new update rate takes effect immediately. 406 if (shouldTimerBeRunning()) { 407 updateTimer(); 408 } 409 } 410 411 private void updatePaintIfInteractive(Paint paint, int interactiveColor) { 412 if (!isInAmbientMode() && paint != null) { 413 paint.setColor(interactiveColor); 414 } 415 } 416 417 private void setInteractiveBackgroundColor(int color) { 418 mInteractiveBackgroundColor = color; 419 updatePaintIfInteractive(mBackgroundPaint, color); 420 } 421 422 private void setInteractiveHourDigitsColor(int color) { 423 mInteractiveHourDigitsColor = color; 424 updatePaintIfInteractive(mHourPaint, color); 425 } 426 427 private void setInteractiveMinuteDigitsColor(int color) { 428 mInteractiveMinuteDigitsColor = color; 429 updatePaintIfInteractive(mMinutePaint, color); 430 } 431 432 private void setInteractiveSecondDigitsColor(int color) { 433 mInteractiveSecondDigitsColor = color; 434 updatePaintIfInteractive(mSecondPaint, color); 435 } 436 437 private String formatTwoDigitNumber(int hour) { 438 return String.format("%02d", hour); 439 } 440 441 private String getAmPmString(int amPm) { 442 return amPm == Calendar.AM ? mAmString : mPmString; 443 } 444 445 @Override 446 public void onDraw(Canvas canvas, Rect bounds) { 447 long now = System.currentTimeMillis(); 448 mCalendar.setTimeInMillis(now); 449 mDate.setTime(now); 450 boolean is24Hour = DateFormat.is24HourFormat(DigitalWatchFaceService.this); 451 452 // Show colons for the first half of each second so the colons blink on when the time 453 // updates. 454 mShouldDrawColons = (System.currentTimeMillis() % 1000) < 500; 455 456 // Draw the background. 457 canvas.drawRect(0, 0, bounds.width(), bounds.height(), mBackgroundPaint); 458 459 // Draw the hours. 460 float x = mXOffset; 461 String hourString; 462 if (is24Hour) { 463 hourString = formatTwoDigitNumber(mCalendar.get(Calendar.HOUR_OF_DAY)); 464 } else { 465 int hour = mCalendar.get(Calendar.HOUR); 466 if (hour == 0) { 467 hour = 12; 468 } 469 hourString = String.valueOf(hour); 470 } 471 canvas.drawText(hourString, x, mYOffset, mHourPaint); 472 x += mHourPaint.measureText(hourString); 473 474 // In ambient and mute modes, always draw the first colon. Otherwise, draw the 475 // first colon for the first half of each second. 476 if (isInAmbientMode() || mMute || mShouldDrawColons) { 477 canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint); 478 } 479 x += mColonWidth; 480 481 // Draw the minutes. 482 String minuteString = formatTwoDigitNumber(mCalendar.get(Calendar.MINUTE)); 483 canvas.drawText(minuteString, x, mYOffset, mMinutePaint); 484 x += mMinutePaint.measureText(minuteString); 485 486 // In unmuted interactive mode, draw a second blinking colon followed by the seconds. 487 // Otherwise, if we're in 12-hour mode, draw AM/PM 488 if (!isInAmbientMode() && !mMute) { 489 if (mShouldDrawColons) { 490 canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint); 491 } 492 x += mColonWidth; 493 canvas.drawText(formatTwoDigitNumber( 494 mCalendar.get(Calendar.SECOND)), x, mYOffset, mSecondPaint); 495 } else if (!is24Hour) { 496 x += mColonWidth; 497 canvas.drawText(getAmPmString( 498 mCalendar.get(Calendar.AM_PM)), x, mYOffset, mAmPmPaint); 499 } 500 501 // Only render the day of week and date if there is no peek card, so they do not bleed 502 // into each other in ambient mode. 503 if (getPeekCardPosition().isEmpty()) { 504 // Day of week 505 canvas.drawText( 506 mDayOfWeekFormat.format(mDate), 507 mXOffset, mYOffset + mLineHeight, mDatePaint); 508 // Date 509 canvas.drawText( 510 mDateFormat.format(mDate), 511 mXOffset, mYOffset + mLineHeight * 2, mDatePaint); 512 } 513 } 514 515 /** 516 * Starts the {@link #mUpdateTimeHandler} timer if it should be running and isn't currently 517 * or stops it if it shouldn't be running but currently is. 518 */ 519 private void updateTimer() { 520 if (Log.isLoggable(TAG, Log.DEBUG)) { 521 Log.d(TAG, "updateTimer"); 522 } 523 mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME); 524 if (shouldTimerBeRunning()) { 525 mUpdateTimeHandler.sendEmptyMessage(MSG_UPDATE_TIME); 526 } 527 } 528 529 /** 530 * Returns whether the {@link #mUpdateTimeHandler} timer should be running. The timer should 531 * only run when we're visible and in interactive mode. 532 */ 533 private boolean shouldTimerBeRunning() { 534 return isVisible() && !isInAmbientMode(); 535 } 536 537 private void updateConfigDataItemAndUiOnStartup() { 538 DigitalWatchFaceUtil.fetchConfigDataMap(mGoogleApiClient, 539 new DigitalWatchFaceUtil.FetchConfigDataMapCallback() { 540 @Override 541 public void onConfigDataMapFetched(DataMap startupConfig) { 542 // If the DataItem hasn't been created yet or some keys are missing, 543 // use the default values. 544 setDefaultValuesForMissingConfigKeys(startupConfig); 545 DigitalWatchFaceUtil.putConfigDataItem(mGoogleApiClient, startupConfig); 546 547 updateUiForConfigDataMap(startupConfig); 548 } 549 } 550 ); 551 } 552 553 private void setDefaultValuesForMissingConfigKeys(DataMap config) { 554 addIntKeyIfMissing(config, DigitalWatchFaceUtil.KEY_BACKGROUND_COLOR, 555 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_BACKGROUND); 556 addIntKeyIfMissing(config, DigitalWatchFaceUtil.KEY_HOURS_COLOR, 557 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_HOUR_DIGITS); 558 addIntKeyIfMissing(config, DigitalWatchFaceUtil.KEY_MINUTES_COLOR, 559 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_MINUTE_DIGITS); 560 addIntKeyIfMissing(config, DigitalWatchFaceUtil.KEY_SECONDS_COLOR, 561 DigitalWatchFaceUtil.COLOR_VALUE_DEFAULT_AND_AMBIENT_SECOND_DIGITS); 562 } 563 564 private void addIntKeyIfMissing(DataMap config, String key, int color) { 565 if (!config.containsKey(key)) { 566 config.putInt(key, color); 567 } 568 } 569 570 @Override // DataApi.DataListener 571 public void onDataChanged(DataEventBuffer dataEvents) { 572 for (DataEvent dataEvent : dataEvents) { 573 if (dataEvent.getType() != DataEvent.TYPE_CHANGED) { 574 continue; 575 } 576 577 DataItem dataItem = dataEvent.getDataItem(); 578 if (!dataItem.getUri().getPath().equals( 579 DigitalWatchFaceUtil.PATH_WITH_FEATURE)) { 580 continue; 581 } 582 583 DataMapItem dataMapItem = DataMapItem.fromDataItem(dataItem); 584 DataMap config = dataMapItem.getDataMap(); 585 if (Log.isLoggable(TAG, Log.DEBUG)) { 586 Log.d(TAG, "Config DataItem updated:" + config); 587 } 588 updateUiForConfigDataMap(config); 589 } 590 } 591 592 private void updateUiForConfigDataMap(final DataMap config) { 593 boolean uiUpdated = false; 594 for (String configKey : config.keySet()) { 595 if (!config.containsKey(configKey)) { 596 continue; 597 } 598 int color = config.getInt(configKey); 599 if (Log.isLoggable(TAG, Log.DEBUG)) { 600 Log.d(TAG, "Found watch face config key: " + configKey + " -> " 601 + Integer.toHexString(color)); 602 } 603 if (updateUiForKey(configKey, color)) { 604 uiUpdated = true; 605 } 606 } 607 if (uiUpdated) { 608 invalidate(); 609 } 610 } 611 612 /** 613 * Updates the color of a UI item according to the given {@code configKey}. Does nothing if 614 * {@code configKey} isn't recognized. 615 * 616 * @return whether UI has been updated 617 */ 618 private boolean updateUiForKey(String configKey, int color) { 619 if (configKey.equals(DigitalWatchFaceUtil.KEY_BACKGROUND_COLOR)) { 620 setInteractiveBackgroundColor(color); 621 } else if (configKey.equals(DigitalWatchFaceUtil.KEY_HOURS_COLOR)) { 622 setInteractiveHourDigitsColor(color); 623 } else if (configKey.equals(DigitalWatchFaceUtil.KEY_MINUTES_COLOR)) { 624 setInteractiveMinuteDigitsColor(color); 625 } else if (configKey.equals(DigitalWatchFaceUtil.KEY_SECONDS_COLOR)) { 626 setInteractiveSecondDigitsColor(color); 627 } else { 628 Log.w(TAG, "Ignoring unknown config key: " + configKey); 629 return false; 630 } 631 return true; 632 } 633 634 @Override // GoogleApiClient.ConnectionCallbacks 635 public void onConnected(Bundle connectionHint) { 636 if (Log.isLoggable(TAG, Log.DEBUG)) { 637 Log.d(TAG, "onConnected: " + connectionHint); 638 } 639 Wearable.DataApi.addListener(mGoogleApiClient, Engine.this); 640 updateConfigDataItemAndUiOnStartup(); 641 } 642 643 @Override // GoogleApiClient.ConnectionCallbacks 644 public void onConnectionSuspended(int cause) { 645 if (Log.isLoggable(TAG, Log.DEBUG)) { 646 Log.d(TAG, "onConnectionSuspended: " + cause); 647 } 648 } 649 650 @Override // GoogleApiClient.OnConnectionFailedListener 651 public void onConnectionFailed(ConnectionResult result) { 652 if (Log.isLoggable(TAG, Log.DEBUG)) { 653 Log.d(TAG, "onConnectionFailed: " + result); 654 } 655 } 656 } 657 } 658