prebuilts/gradle/WatchFace/Wearable/src/main/java/com/example/android/wearable/watchface/FitDistanceWatchFaceService.java - platform/developers/build - Gitiles

 /*
  * Copyright (C) 2014 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.example.android.wearable.watchface;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.Typeface;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.support.wearable.watchface.CanvasWatchFaceService;
 import android.support.wearable.watchface.WatchFaceStyle;
 import android.text.format.DateFormat;
 import android.util.Log;
 import android.view.SurfaceHolder;
 import android.view.WindowInsets;

 import com.google.android.gms.common.ConnectionResult;
 import com.google.android.gms.common.Scopes;
 import com.google.android.gms.common.api.GoogleApiClient;
 import com.google.android.gms.common.api.PendingResult;
 import com.google.android.gms.common.api.ResultCallback;
 import com.google.android.gms.common.api.Scope;
 import com.google.android.gms.common.api.Status;
 import com.google.android.gms.fitness.Fitness;
 import com.google.android.gms.fitness.FitnessStatusCodes;
 import com.google.android.gms.fitness.data.DataPoint;
 import com.google.android.gms.fitness.data.DataType;
 import com.google.android.gms.fitness.data.Field;
 import com.google.android.gms.fitness.result.DailyTotalResult;

 import java.util.Calendar;
 import java.util.List;
 import java.util.TimeZone;
 import java.util.concurrent.TimeUnit;

 /**
  * Displays the user's daily distance total via Google Fit. Distance is polled initially when the
  * Google API Client successfully connects and once a minute after that via the onTimeTick callback.
  * If you want more frequent updates, you will want to add your own  Handler.
  *
  * Authentication IS a requirement to request distance from Google Fit on Wear. Otherwise, distance
  * will always come back as zero (or stay at whatever the distance was prior to you
  * de-authorizing watchface). To authenticate and communicate with Google Fit, you must create a
  * project in the Google Developers Console, activate the Fitness API, create an OAuth 2.0
  * client ID, and register the public certificate from your app's signed APK. More details can be
  * found here: https://developers.google.com/fit/android/get-started#step_3_enable_the_fitness_api
  *
  * In ambient mode, the seconds are replaced with an AM/PM indicator.
  *
  * On devices with low-bit ambient mode, the text is drawn without anti-aliasing. On devices which
  * require burn-in protection, the hours are drawn in normal rather than bold.
  *
  */
 public class FitDistanceWatchFaceService extends CanvasWatchFaceService {

     private static final String TAG = "DistanceWatchFace";

     private static final Typeface BOLD_TYPEFACE =
             Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD);
     private static final Typeface NORMAL_TYPEFACE =
             Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL);

     /**
      * Update rate in milliseconds for active mode (non-ambient).
      */
     private static final long ACTIVE_INTERVAL_MS = TimeUnit.SECONDS.toMillis(1);

     @Override
     public Engine onCreateEngine() {
         return new Engine();
     }

     private class Engine extends CanvasWatchFaceService.Engine implements
             GoogleApiClient.ConnectionCallbacks,
             GoogleApiClient.OnConnectionFailedListener,
             ResultCallback<DailyTotalResult> {

         private static final int BACKGROUND_COLOR = Color.BLACK;
         private static final int TEXT_HOURS_MINS_COLOR = Color.WHITE;
         private static final int TEXT_SECONDS_COLOR = Color.GRAY;
         private static final int TEXT_AM_PM_COLOR = Color.GRAY;
         private static final int TEXT_COLON_COLOR = Color.GRAY;
         private static final int TEXT_DISTANCE_COUNT_COLOR = Color.GRAY;

         private static final String COLON_STRING = ":";

         private static final int MSG_UPDATE_TIME = 0;

         /* Handler to update the time periodically in interactive mode. */
         private final Handler mUpdateTimeHandler = new Handler() {
             @Override
             public void handleMessage(Message message) {
                 switch (message.what) {
                     case MSG_UPDATE_TIME:
                         Log.v(TAG, "updating time");
                         invalidate();
                         if (shouldUpdateTimeHandlerBeRunning()) {
                             long timeMs = System.currentTimeMillis();
                             long delayMs =
                                     ACTIVE_INTERVAL_MS - (timeMs % ACTIVE_INTERVAL_MS);
                             mUpdateTimeHandler.sendEmptyMessageDelayed(MSG_UPDATE_TIME, delayMs);
                         }
                         break;
                 }
             }
         };

         /**
          * Handles time zone and locale changes.
          */
         private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 mCalendar.setTimeZone(TimeZone.getDefault());
                 invalidate();
             }
         };

         /**
          * Unregistering an unregistered receiver throws an exception. Keep track of the
          * registration state to prevent that.
          */
         private boolean mRegisteredReceiver = false;

         private Paint mHourPaint;
         private Paint mMinutePaint;
         private Paint mSecondPaint;
         private Paint mAmPmPaint;
         private Paint mColonPaint;
         private Paint mDistanceCountPaint;

         private float mColonWidth;

         private Calendar mCalendar;

         private float mXOffset;
         private float mXDistanceOffset;
         private float mYOffset;
         private float mLineHeight;

         private String mAmString;
         private String mPmString;


         /**
          * Whether the display supports fewer bits for each color in ambient mode. When true, we
          * disable anti-aliasing in ambient mode.
          */
         private boolean mLowBitAmbient;

         /*
          * Google API Client used to make Google Fit requests for step data.
          */
         private GoogleApiClient mGoogleApiClient;

         private boolean mDistanceRequested;

         private float mDistanceTotal = 0;

         @Override
         public void onCreate(SurfaceHolder holder) {
             Log.d(TAG, "onCreate");

             super.onCreate(holder);

             mDistanceRequested = false;
             mGoogleApiClient = new GoogleApiClient.Builder(FitDistanceWatchFaceService.this)
                     .addConnectionCallbacks(this)
                     .addOnConnectionFailedListener(this)
                     .addApi(Fitness.HISTORY_API)
                     .addApi(Fitness.RECORDING_API)
                     .addScope(new Scope(Scopes.FITNESS_LOCATION_READ))
                     // When user has multiple accounts, useDefaultAccount() allows Google Fit to
                     // associated with the main account for steps. It also replaces the need for
                     // a scope request.
                     .useDefaultAccount()
                     .build();

             setWatchFaceStyle(new WatchFaceStyle.Builder(FitDistanceWatchFaceService.this)
                     .setCardPeekMode(WatchFaceStyle.PEEK_MODE_VARIABLE)
                     .setBackgroundVisibility(WatchFaceStyle.BACKGROUND_VISIBILITY_INTERRUPTIVE)
                     .setShowSystemUiTime(false)
                     .build());

             Resources resources = getResources();

             mYOffset = resources.getDimension(R.dimen.fit_y_offset);
             mLineHeight = resources.getDimension(R.dimen.fit_line_height);
             mAmString = resources.getString(R.string.fit_am);
             mPmString = resources.getString(R.string.fit_pm);

             mHourPaint = createTextPaint(TEXT_HOURS_MINS_COLOR, BOLD_TYPEFACE);
             mMinutePaint = createTextPaint(TEXT_HOURS_MINS_COLOR);
             mSecondPaint = createTextPaint(TEXT_SECONDS_COLOR);
             mAmPmPaint = createTextPaint(TEXT_AM_PM_COLOR);
             mColonPaint = createTextPaint(TEXT_COLON_COLOR);
             mDistanceCountPaint = createTextPaint(TEXT_DISTANCE_COUNT_COLOR);

             mCalendar = Calendar.getInstance();

         }

         @Override
         public void onDestroy() {
             mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME);
             super.onDestroy();
         }

         private Paint createTextPaint(int color) {
             return createTextPaint(color, NORMAL_TYPEFACE);
         }

         private Paint createTextPaint(int color, Typeface typeface) {
             Paint paint = new Paint();
             paint.setColor(color);
             paint.setTypeface(typeface);
             paint.setAntiAlias(true);
             return paint;
         }

         @Override
         public void onVisibilityChanged(boolean visible) {
             Log.d(TAG, "onVisibilityChanged: " + visible);

             super.onVisibilityChanged(visible);

             if (visible) {
                 mGoogleApiClient.connect();

                 registerReceiver();

                 // Update time zone and date formats, in case they changed while we weren't visible.
                 mCalendar.setTimeZone(TimeZone.getDefault());
             } else {
                 unregisterReceiver();

                 if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
                     mGoogleApiClient.disconnect();
                 }
             }

             // Whether the timer should be running depends on whether we're visible (as well as
             // whether we're in ambient mode), so we may need to start or stop the timer.
             updateTimer();
         }


         private void registerReceiver() {
             if (mRegisteredReceiver) {
                 return;
             }
             mRegisteredReceiver = true;
             IntentFilter filter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED);
             FitDistanceWatchFaceService.this.registerReceiver(mReceiver, filter);
         }

         private void unregisterReceiver() {
             if (!mRegisteredReceiver) {
                 return;
             }
             mRegisteredReceiver = false;
             FitDistanceWatchFaceService.this.unregisterReceiver(mReceiver);
         }

         @Override
         public void onApplyWindowInsets(WindowInsets insets) {
             Log.d(TAG, "onApplyWindowInsets: " + (insets.isRound() ? "round" : "square"));

             super.onApplyWindowInsets(insets);

             // Load resources that have alternate values for round watches.
             Resources resources = FitDistanceWatchFaceService.this.getResources();
             boolean isRound = insets.isRound();
             mXOffset = resources.getDimension(isRound
                     ? R.dimen.fit_x_offset_round : R.dimen.fit_x_offset);
             mXDistanceOffset =
                     resources.getDimension(
                             isRound ?
                             R.dimen.fit_steps_or_distance_x_offset_round :
                             R.dimen.fit_steps_or_distance_x_offset);
             float textSize = resources.getDimension(isRound
                     ? R.dimen.fit_text_size_round : R.dimen.fit_text_size);
             float amPmSize = resources.getDimension(isRound
                     ? R.dimen.fit_am_pm_size_round : R.dimen.fit_am_pm_size);

             mHourPaint.setTextSize(textSize);
             mMinutePaint.setTextSize(textSize);
             mSecondPaint.setTextSize(textSize);
             mAmPmPaint.setTextSize(amPmSize);
             mColonPaint.setTextSize(textSize);
             mDistanceCountPaint.setTextSize(
                     resources.getDimension(R.dimen.fit_steps_or_distance_text_size));

             mColonWidth = mColonPaint.measureText(COLON_STRING);
         }

         @Override
         public void onPropertiesChanged(Bundle properties) {
             super.onPropertiesChanged(properties);

             boolean burnInProtection = properties.getBoolean(PROPERTY_BURN_IN_PROTECTION, false);
             mHourPaint.setTypeface(burnInProtection ? NORMAL_TYPEFACE : BOLD_TYPEFACE);

             mLowBitAmbient = properties.getBoolean(PROPERTY_LOW_BIT_AMBIENT, false);

             Log.d(TAG, "onPropertiesChanged: burn-in protection = " + burnInProtection
                     + ", low-bit ambient = " + mLowBitAmbient);

         }

         @Override
         public void onTimeTick() {
             super.onTimeTick();
             Log.d(TAG, "onTimeTick: ambient = " + isInAmbientMode());
             getTotalDistance();
             invalidate();
         }

         @Override
         public void onAmbientModeChanged(boolean inAmbientMode) {
             super.onAmbientModeChanged(inAmbientMode);
             Log.d(TAG, "onAmbientModeChanged: " + inAmbientMode);

             if (mLowBitAmbient) {
                 boolean antiAlias = !inAmbientMode;;
                 mHourPaint.setAntiAlias(antiAlias);
                 mMinutePaint.setAntiAlias(antiAlias);
                 mSecondPaint.setAntiAlias(antiAlias);
                 mAmPmPaint.setAntiAlias(antiAlias);
                 mColonPaint.setAntiAlias(antiAlias);
                 mDistanceCountPaint.setAntiAlias(antiAlias);
             }
             invalidate();

             // Whether the timer should be running depends on whether we're in ambient mode (as well
             // as whether we're visible), so we may need to start or stop the timer.
             updateTimer();
         }

         private String formatTwoDigitNumber(int hour) {
             return String.format("%02d", hour);
         }

         private String getAmPmString(int amPm) {
             return amPm == Calendar.AM ? mAmString : mPmString;
         }

         @Override
         public void onDraw(Canvas canvas, Rect bounds) {
             long now = System.currentTimeMillis();
             mCalendar.setTimeInMillis(now);
             boolean is24Hour = DateFormat.is24HourFormat(FitDistanceWatchFaceService.this);

             // Draw the background.
             canvas.drawColor(BACKGROUND_COLOR);

             // Draw the hours.
             float x = mXOffset;
             String hourString;
             if (is24Hour) {
                 hourString = formatTwoDigitNumber(mCalendar.get(Calendar.HOUR_OF_DAY));
             } else {
                 int hour = mCalendar.get(Calendar.HOUR);
                 if (hour == 0) {
                     hour = 12;
                 }
                 hourString = String.valueOf(hour);
             }
             canvas.drawText(hourString, x, mYOffset, mHourPaint);
             x += mHourPaint.measureText(hourString);

             // Draw first colon (between hour and minute).
             canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint);

             x += mColonWidth;

             // Draw the minutes.
             String minuteString = formatTwoDigitNumber(mCalendar.get(Calendar.MINUTE));
             canvas.drawText(minuteString, x, mYOffset, mMinutePaint);
             x += mMinutePaint.measureText(minuteString);

             // In interactive mode, draw a second colon followed by the seconds.
             // Otherwise, if we're in 12-hour mode, draw AM/PM
             if (!isInAmbientMode()) {
                 canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint);

                 x += mColonWidth;
                 canvas.drawText(formatTwoDigitNumber(
                         mCalendar.get(Calendar.SECOND)), x, mYOffset, mSecondPaint);
             } else if (!is24Hour) {
                 x += mColonWidth;
                 canvas.drawText(getAmPmString(
                         mCalendar.get(Calendar.AM_PM)), x, mYOffset, mAmPmPaint);
             }

             // Only render distance if there is no peek card, so they do not bleed into each other
             // in ambient mode.
             if (getPeekCardPosition().isEmpty()) {
                 canvas.drawText(
                         getString(R.string.fit_distance, mDistanceTotal),
                         mXDistanceOffset,
                         mYOffset + mLineHeight,
                         mDistanceCountPaint);
             }
         }

         /**
          * Starts the {@link #mUpdateTimeHandler} timer if it should be running and isn't currently
          * or stops it if it shouldn't be running but currently is.
          */
         private void updateTimer() {
             Log.d(TAG, "updateTimer");

             mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME);
             if (shouldUpdateTimeHandlerBeRunning()) {
                 mUpdateTimeHandler.sendEmptyMessage(MSG_UPDATE_TIME);
             }
         }

         /**
          * Returns whether the {@link #mUpdateTimeHandler} timer should be running. The timer should
          * only run when we're visible and in interactive mode.
          */
         private boolean shouldUpdateTimeHandlerBeRunning() {
             return isVisible() && !isInAmbientMode();
         }

         private void getTotalDistance() {

             Log.d(TAG, "getTotalDistance()");

             if ((mGoogleApiClient != null)
                     && (mGoogleApiClient.isConnected())
                     && (!mDistanceRequested)) {

                 mDistanceRequested = true;

                 PendingResult<DailyTotalResult> distanceResult =
                         Fitness.HistoryApi.readDailyTotal(
                                 mGoogleApiClient,
                                 DataType.TYPE_DISTANCE_DELTA);

                 distanceResult.setResultCallback(this);
             }
         }

         @Override
         public void onConnected(Bundle connectionHint) {
             Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnected: " + connectionHint);

             mDistanceRequested = false;

             // Subscribe covers devices that do not have Google Fit installed.
             subscribeToDistance();

             getTotalDistance();
         }

         /*
          * Subscribes to distance.
          */
         private void subscribeToDistance() {

             if ((mGoogleApiClient != null) && (mGoogleApiClient.isConnecting())) {

                 Fitness.RecordingApi.subscribe(mGoogleApiClient, DataType.TYPE_DISTANCE_DELTA)
                         .setResultCallback(new ResultCallback<Status>() {
                             @Override
                             public void onResult(Status status) {
                                 if (status.isSuccess()) {
                                     if (status.getStatusCode()
                                             == FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED) {
                                         Log.i(TAG, "Existing subscription for activity detected.");
                                     } else {
                                         Log.i(TAG, "Successfully subscribed!");
                                     }
                                 } else {
                                     Log.i(TAG, "There was a problem subscribing.");
                                 }
                             }
                         });
             }
         }

         @Override
         public void onConnectionSuspended(int cause) {
             Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnectionSuspended: " + cause);
         }

         @Override
         public void onConnectionFailed(ConnectionResult result) {
             Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnectionFailed: " + result);
         }

         @Override
         public void onResult(DailyTotalResult dailyTotalResult) {
             Log.d(TAG, "mGoogleApiAndFitCallbacks.onResult(): " + dailyTotalResult);

             mDistanceRequested = false;

             if (dailyTotalResult.getStatus().isSuccess()) {

                 List<DataPoint> points = dailyTotalResult.getTotal().getDataPoints();

                 if (!points.isEmpty()) {
                     mDistanceTotal = points.get(0).getValue(Field.FIELD_DISTANCE).asFloat();
                     Log.d(TAG, "distance updated: " + mDistanceTotal);
                 }
             } else {
                 Log.e(TAG, "onResult() failed! " + dailyTotalResult.getStatus().getStatusMessage());
             }
         }
     }
 }
	/*
	* Copyright (C) 2014 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.example.android.wearable.watchface;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.res.Resources;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.graphics.Typeface;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.Message;
	import android.support.wearable.watchface.CanvasWatchFaceService;
	import android.support.wearable.watchface.WatchFaceStyle;
	import android.text.format.DateFormat;
	import android.util.Log;
	import android.view.SurfaceHolder;
	import android.view.WindowInsets;

	import com.google.android.gms.common.ConnectionResult;
	import com.google.android.gms.common.Scopes;
	import com.google.android.gms.common.api.GoogleApiClient;
	import com.google.android.gms.common.api.PendingResult;
	import com.google.android.gms.common.api.ResultCallback;
	import com.google.android.gms.common.api.Scope;
	import com.google.android.gms.common.api.Status;
	import com.google.android.gms.fitness.Fitness;
	import com.google.android.gms.fitness.FitnessStatusCodes;
	import com.google.android.gms.fitness.data.DataPoint;
	import com.google.android.gms.fitness.data.DataType;
	import com.google.android.gms.fitness.data.Field;
	import com.google.android.gms.fitness.result.DailyTotalResult;

	import java.util.Calendar;
	import java.util.List;
	import java.util.TimeZone;
	import java.util.concurrent.TimeUnit;

	/**
	* Displays the user's daily distance total via Google Fit. Distance is polled initially when the
	* Google API Client successfully connects and once a minute after that via the onTimeTick callback.
	* If you want more frequent updates, you will want to add your own Handler.
	*
	* Authentication IS a requirement to request distance from Google Fit on Wear. Otherwise, distance
	* will always come back as zero (or stay at whatever the distance was prior to you
	* de-authorizing watchface). To authenticate and communicate with Google Fit, you must create a
	* project in the Google Developers Console, activate the Fitness API, create an OAuth 2.0
	* client ID, and register the public certificate from your app's signed APK. More details can be
	* found here: https://developers.google.com/fit/android/get-started#step_3_enable_the_fitness_api
	*
	* In ambient mode, the seconds are replaced with an AM/PM indicator.
	*
	* On devices with low-bit ambient mode, the text is drawn without anti-aliasing. On devices which
	* require burn-in protection, the hours are drawn in normal rather than bold.
	*
	*/
	public class FitDistanceWatchFaceService extends CanvasWatchFaceService {

	private static final String TAG = "DistanceWatchFace";

	private static final Typeface BOLD_TYPEFACE =
	Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD);
	private static final Typeface NORMAL_TYPEFACE =
	Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL);

	/**
	* Update rate in milliseconds for active mode (non-ambient).
	*/
	private static final long ACTIVE_INTERVAL_MS = TimeUnit.SECONDS.toMillis(1);

	@Override
	public Engine onCreateEngine() {
	return new Engine();
	}

	private class Engine extends CanvasWatchFaceService.Engine implements
	GoogleApiClient.ConnectionCallbacks,
	GoogleApiClient.OnConnectionFailedListener,
	ResultCallback<DailyTotalResult> {

	private static final int BACKGROUND_COLOR = Color.BLACK;
	private static final int TEXT_HOURS_MINS_COLOR = Color.WHITE;
	private static final int TEXT_SECONDS_COLOR = Color.GRAY;
	private static final int TEXT_AM_PM_COLOR = Color.GRAY;
	private static final int TEXT_COLON_COLOR = Color.GRAY;
	private static final int TEXT_DISTANCE_COUNT_COLOR = Color.GRAY;

	private static final String COLON_STRING = ":";

	private static final int MSG_UPDATE_TIME = 0;

	/* Handler to update the time periodically in interactive mode. */
	private final Handler mUpdateTimeHandler = new Handler() {
	@Override
	public void handleMessage(Message message) {
	switch (message.what) {
	case MSG_UPDATE_TIME:
	Log.v(TAG, "updating time");
	invalidate();
	if (shouldUpdateTimeHandlerBeRunning()) {
	long timeMs = System.currentTimeMillis();
	long delayMs =
	ACTIVE_INTERVAL_MS - (timeMs % ACTIVE_INTERVAL_MS);
	mUpdateTimeHandler.sendEmptyMessageDelayed(MSG_UPDATE_TIME, delayMs);
	}
	break;
	}
	}
	};

	/**
	* Handles time zone and locale changes.
	*/
	private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	mCalendar.setTimeZone(TimeZone.getDefault());
	invalidate();
	}
	};

	/**
	* Unregistering an unregistered receiver throws an exception. Keep track of the
	* registration state to prevent that.
	*/
	private boolean mRegisteredReceiver = false;

	private Paint mHourPaint;
	private Paint mMinutePaint;
	private Paint mSecondPaint;
	private Paint mAmPmPaint;
	private Paint mColonPaint;
	private Paint mDistanceCountPaint;

	private float mColonWidth;

	private Calendar mCalendar;

	private float mXOffset;
	private float mXDistanceOffset;
	private float mYOffset;
	private float mLineHeight;

	private String mAmString;
	private String mPmString;


	/**
	* Whether the display supports fewer bits for each color in ambient mode. When true, we
	* disable anti-aliasing in ambient mode.
	*/
	private boolean mLowBitAmbient;

	/*
	* Google API Client used to make Google Fit requests for step data.
	*/
	private GoogleApiClient mGoogleApiClient;

	private boolean mDistanceRequested;

	private float mDistanceTotal = 0;

	@Override
	public void onCreate(SurfaceHolder holder) {
	Log.d(TAG, "onCreate");

	super.onCreate(holder);

	mDistanceRequested = false;
	mGoogleApiClient = new GoogleApiClient.Builder(FitDistanceWatchFaceService.this)
	.addConnectionCallbacks(this)
	.addOnConnectionFailedListener(this)
	.addApi(Fitness.HISTORY_API)
	.addApi(Fitness.RECORDING_API)
	.addScope(new Scope(Scopes.FITNESS_LOCATION_READ))
	// When user has multiple accounts, useDefaultAccount() allows Google Fit to
	// associated with the main account for steps. It also replaces the need for
	// a scope request.
	.useDefaultAccount()
	.build();

	setWatchFaceStyle(new WatchFaceStyle.Builder(FitDistanceWatchFaceService.this)
	.setCardPeekMode(WatchFaceStyle.PEEK_MODE_VARIABLE)
	.setBackgroundVisibility(WatchFaceStyle.BACKGROUND_VISIBILITY_INTERRUPTIVE)
	.setShowSystemUiTime(false)
	.build());

	Resources resources = getResources();

	mYOffset = resources.getDimension(R.dimen.fit_y_offset);
	mLineHeight = resources.getDimension(R.dimen.fit_line_height);
	mAmString = resources.getString(R.string.fit_am);
	mPmString = resources.getString(R.string.fit_pm);

	mHourPaint = createTextPaint(TEXT_HOURS_MINS_COLOR, BOLD_TYPEFACE);
	mMinutePaint = createTextPaint(TEXT_HOURS_MINS_COLOR);
	mSecondPaint = createTextPaint(TEXT_SECONDS_COLOR);
	mAmPmPaint = createTextPaint(TEXT_AM_PM_COLOR);
	mColonPaint = createTextPaint(TEXT_COLON_COLOR);
	mDistanceCountPaint = createTextPaint(TEXT_DISTANCE_COUNT_COLOR);

	mCalendar = Calendar.getInstance();

	}

	@Override
	public void onDestroy() {
	mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME);
	super.onDestroy();
	}

	private Paint createTextPaint(int color) {
	return createTextPaint(color, NORMAL_TYPEFACE);
	}

	private Paint createTextPaint(int color, Typeface typeface) {
	Paint paint = new Paint();
	paint.setColor(color);
	paint.setTypeface(typeface);
	paint.setAntiAlias(true);
	return paint;
	}

	@Override
	public void onVisibilityChanged(boolean visible) {
	Log.d(TAG, "onVisibilityChanged: " + visible);

	super.onVisibilityChanged(visible);

	if (visible) {
	mGoogleApiClient.connect();

	registerReceiver();

	// Update time zone and date formats, in case they changed while we weren't visible.
	mCalendar.setTimeZone(TimeZone.getDefault());
	} else {
	unregisterReceiver();

	if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
	mGoogleApiClient.disconnect();
	}
	}

	// Whether the timer should be running depends on whether we're visible (as well as
	// whether we're in ambient mode), so we may need to start or stop the timer.
	updateTimer();
	}


	private void registerReceiver() {
	if (mRegisteredReceiver) {
	return;
	}
	mRegisteredReceiver = true;
	IntentFilter filter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED);
	FitDistanceWatchFaceService.this.registerReceiver(mReceiver, filter);
	}

	private void unregisterReceiver() {
	if (!mRegisteredReceiver) {
	return;
	}
	mRegisteredReceiver = false;
	FitDistanceWatchFaceService.this.unregisterReceiver(mReceiver);
	}

	@Override
	public void onApplyWindowInsets(WindowInsets insets) {
	Log.d(TAG, "onApplyWindowInsets: " + (insets.isRound() ? "round" : "square"));

	super.onApplyWindowInsets(insets);

	// Load resources that have alternate values for round watches.
	Resources resources = FitDistanceWatchFaceService.this.getResources();
	boolean isRound = insets.isRound();
	mXOffset = resources.getDimension(isRound
	? R.dimen.fit_x_offset_round : R.dimen.fit_x_offset);
	mXDistanceOffset =
	resources.getDimension(
	isRound ?
	R.dimen.fit_steps_or_distance_x_offset_round :
	R.dimen.fit_steps_or_distance_x_offset);
	float textSize = resources.getDimension(isRound
	? R.dimen.fit_text_size_round : R.dimen.fit_text_size);
	float amPmSize = resources.getDimension(isRound
	? R.dimen.fit_am_pm_size_round : R.dimen.fit_am_pm_size);

	mHourPaint.setTextSize(textSize);
	mMinutePaint.setTextSize(textSize);
	mSecondPaint.setTextSize(textSize);
	mAmPmPaint.setTextSize(amPmSize);
	mColonPaint.setTextSize(textSize);
	mDistanceCountPaint.setTextSize(
	resources.getDimension(R.dimen.fit_steps_or_distance_text_size));

	mColonWidth = mColonPaint.measureText(COLON_STRING);
	}

	@Override
	public void onPropertiesChanged(Bundle properties) {
	super.onPropertiesChanged(properties);

	boolean burnInProtection = properties.getBoolean(PROPERTY_BURN_IN_PROTECTION, false);
	mHourPaint.setTypeface(burnInProtection ? NORMAL_TYPEFACE : BOLD_TYPEFACE);

	mLowBitAmbient = properties.getBoolean(PROPERTY_LOW_BIT_AMBIENT, false);

	Log.d(TAG, "onPropertiesChanged: burn-in protection = " + burnInProtection
	+ ", low-bit ambient = " + mLowBitAmbient);

	}

	@Override
	public void onTimeTick() {
	super.onTimeTick();
	Log.d(TAG, "onTimeTick: ambient = " + isInAmbientMode());
	getTotalDistance();
	invalidate();
	}

	@Override
	public void onAmbientModeChanged(boolean inAmbientMode) {
	super.onAmbientModeChanged(inAmbientMode);
	Log.d(TAG, "onAmbientModeChanged: " + inAmbientMode);

	if (mLowBitAmbient) {
	boolean antiAlias = !inAmbientMode;;
	mHourPaint.setAntiAlias(antiAlias);
	mMinutePaint.setAntiAlias(antiAlias);
	mSecondPaint.setAntiAlias(antiAlias);
	mAmPmPaint.setAntiAlias(antiAlias);
	mColonPaint.setAntiAlias(antiAlias);
	mDistanceCountPaint.setAntiAlias(antiAlias);
	}
	invalidate();

	// Whether the timer should be running depends on whether we're in ambient mode (as well
	// as whether we're visible), so we may need to start or stop the timer.
	updateTimer();
	}

	private String formatTwoDigitNumber(int hour) {
	return String.format("%02d", hour);
	}

	private String getAmPmString(int amPm) {
	return amPm == Calendar.AM ? mAmString : mPmString;
	}

	@Override
	public void onDraw(Canvas canvas, Rect bounds) {
	long now = System.currentTimeMillis();
	mCalendar.setTimeInMillis(now);
	boolean is24Hour = DateFormat.is24HourFormat(FitDistanceWatchFaceService.this);

	// Draw the background.
	canvas.drawColor(BACKGROUND_COLOR);

	// Draw the hours.
	float x = mXOffset;
	String hourString;
	if (is24Hour) {
	hourString = formatTwoDigitNumber(mCalendar.get(Calendar.HOUR_OF_DAY));
	} else {
	int hour = mCalendar.get(Calendar.HOUR);
	if (hour == 0) {
	hour = 12;
	}
	hourString = String.valueOf(hour);
	}
	canvas.drawText(hourString, x, mYOffset, mHourPaint);
	x += mHourPaint.measureText(hourString);

	// Draw first colon (between hour and minute).
	canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint);

	x += mColonWidth;

	// Draw the minutes.
	String minuteString = formatTwoDigitNumber(mCalendar.get(Calendar.MINUTE));
	canvas.drawText(minuteString, x, mYOffset, mMinutePaint);
	x += mMinutePaint.measureText(minuteString);

	// In interactive mode, draw a second colon followed by the seconds.
	// Otherwise, if we're in 12-hour mode, draw AM/PM
	if (!isInAmbientMode()) {
	canvas.drawText(COLON_STRING, x, mYOffset, mColonPaint);

	x += mColonWidth;
	canvas.drawText(formatTwoDigitNumber(
	mCalendar.get(Calendar.SECOND)), x, mYOffset, mSecondPaint);
	} else if (!is24Hour) {
	x += mColonWidth;
	canvas.drawText(getAmPmString(
	mCalendar.get(Calendar.AM_PM)), x, mYOffset, mAmPmPaint);
	}

	// Only render distance if there is no peek card, so they do not bleed into each other
	// in ambient mode.
	if (getPeekCardPosition().isEmpty()) {
	canvas.drawText(
	getString(R.string.fit_distance, mDistanceTotal),
	mXDistanceOffset,
	mYOffset + mLineHeight,
	mDistanceCountPaint);
	}
	}

	/**
	* Starts the {@link #mUpdateTimeHandler} timer if it should be running and isn't currently
	* or stops it if it shouldn't be running but currently is.
	*/
	private void updateTimer() {
	Log.d(TAG, "updateTimer");

	mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME);
	if (shouldUpdateTimeHandlerBeRunning()) {
	mUpdateTimeHandler.sendEmptyMessage(MSG_UPDATE_TIME);
	}
	}

	/**
	* Returns whether the {@link #mUpdateTimeHandler} timer should be running. The timer should
	* only run when we're visible and in interactive mode.
	*/
	private boolean shouldUpdateTimeHandlerBeRunning() {
	return isVisible() && !isInAmbientMode();
	}

	private void getTotalDistance() {

	Log.d(TAG, "getTotalDistance()");

	if ((mGoogleApiClient != null)
	&& (mGoogleApiClient.isConnected())
	&& (!mDistanceRequested)) {

	mDistanceRequested = true;

	PendingResult<DailyTotalResult> distanceResult =
	Fitness.HistoryApi.readDailyTotal(
	mGoogleApiClient,
	DataType.TYPE_DISTANCE_DELTA);

	distanceResult.setResultCallback(this);
	}
	}

	@Override
	public void onConnected(Bundle connectionHint) {
	Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnected: " + connectionHint);

	mDistanceRequested = false;

	// Subscribe covers devices that do not have Google Fit installed.
	subscribeToDistance();

	getTotalDistance();
	}

	/*
	* Subscribes to distance.
	*/
	private void subscribeToDistance() {

	if ((mGoogleApiClient != null) && (mGoogleApiClient.isConnecting())) {

	Fitness.RecordingApi.subscribe(mGoogleApiClient, DataType.TYPE_DISTANCE_DELTA)
	.setResultCallback(new ResultCallback<Status>() {
	@Override
	public void onResult(Status status) {
	if (status.isSuccess()) {
	if (status.getStatusCode()
	== FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED) {
	Log.i(TAG, "Existing subscription for activity detected.");
	} else {
	Log.i(TAG, "Successfully subscribed!");
	}
	} else {
	Log.i(TAG, "There was a problem subscribing.");
	}
	}
	});
	}
	}

	@Override
	public void onConnectionSuspended(int cause) {
	Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnectionSuspended: " + cause);
	}

	@Override
	public void onConnectionFailed(ConnectionResult result) {
	Log.d(TAG, "mGoogleApiAndFitCallbacks.onConnectionFailed: " + result);
	}

	@Override
	public void onResult(DailyTotalResult dailyTotalResult) {
	Log.d(TAG, "mGoogleApiAndFitCallbacks.onResult(): " + dailyTotalResult);

	mDistanceRequested = false;

	if (dailyTotalResult.getStatus().isSuccess()) {

	List<DataPoint> points = dailyTotalResult.getTotal().getDataPoints();

	if (!points.isEmpty()) {
	mDistanceTotal = points.get(0).getValue(Field.FIELD_DISTANCE).asFloat();
	Log.d(TAG, "distance updated: " + mDistanceTotal);
	}
	} else {
	Log.e(TAG, "onResult() failed! " + dailyTotalResult.getStatus().getStatusMessage());
	}
	}
	}
	}