/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.speedtracker;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.wearable.DataApi;
import com.google.android.gms.wearable.PutDataMapRequest;
import com.google.android.gms.wearable.PutDataRequest;
import com.google.android.gms.wearable.Wearable;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Bundle;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;
import com.example.android.wearable.speedtracker.common.Constants;
import com.example.android.wearable.speedtracker.common.LocationEntry;
import com.example.android.wearable.speedtracker.ui.LocationSettingActivity;
import java.util.Calendar;
/**
* The main activity for the wearable app. User can pick a speed limit, and after this activity
* obtains a fix on the GPS, it starts reporting the speed. In addition to showing the current
* speed, if user's speed gets close to the selected speed limit, the color of speed turns yellow
* and if the user exceeds the speed limit, it will turn red. In order to show the user that GPS
* location data is coming in, a small green dot keeps on blinking while GPS data is available.
*/
public class WearableMainActivity extends Activity implements GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener, LocationListener {
private static final String TAG = "WearableActivity";
private static final long UPDATE_INTERVAL_MS = 5 * 1000;
private static final long FASTEST_INTERVAL_MS = 5 * 1000;
public static final float MPH_IN_METERS_PER_SECOND = 2.23694f;
public static final String PREFS_SPEED_LIMIT_KEY = "speed_limit";
public static final int SPEED_LIMIT_DEFAULT_MPH = 45;
private static final long INDICATOR_DOT_FADE_AWAY_MS = 500L;
private GoogleApiClient mGoogleApiClient;
private TextView mSpeedLimitText;
private TextView mCurrentSpeedText;
private ImageView mSaveImageView;
private TextView mAcquiringGps;
private TextView mCurrentSpeedMphText;
private int mCurrentSpeedLimit;
private float mCurrentSpeed;
private View mDot;
private Handler mHandler = new Handler();
private Calendar mCalendar;
private boolean mSaveGpsLocation;
private enum SpeedState {
BELOW(R.color.speed_below), CLOSE(R.color.speed_close), ABOVE(R.color.speed_above);
private int mColor;
SpeedState(int color) {
mColor = color;
}
int getColor() {
return mColor;
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_activity);
if (!hasGps()) {
// If this hardware doesn't support GPS, we prefer to exit.
// Note that when such device is connected to a phone with GPS capabilities, the
// framework automatically routes the location requests to the phone. For this
// application, this would not be desirable so we exit the app but for some other
// applications, that might be a valid scenario.
Log.w(TAG, "This hardware doesn't have GPS, so we exit");
new AlertDialog.Builder(this)
.setMessage(getString(R.string.gps_not_available))
.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int id) {
finish();
dialog.cancel();
}
})
.setOnDismissListener(new DialogInterface.OnDismissListener() {
@Override
public void onDismiss(DialogInterface dialog) {
dialog.cancel();
finish();
}
})
.setCancelable(false)
.create()
.show();
}
setupViews();
updateSpeedVisibility(false);
setSpeedLimit();
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addApi(LocationServices.API)
.addApi(Wearable.API)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();
mGoogleApiClient.connect();
}
private void setupViews() {
mSpeedLimitText = (TextView) findViewById(R.id.max_speed_text);
mCurrentSpeedText = (TextView) findViewById(R.id.current_speed_text);
mSaveImageView = (ImageView) findViewById(R.id.saving);
ImageButton settingButton = (ImageButton) findViewById(R.id.settings);
mAcquiringGps = (TextView) findViewById(R.id.acquiring_gps);
mCurrentSpeedMphText = (TextView) findViewById(R.id.current_speed_mph);
mDot = findViewById(R.id.dot);
settingButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent speedIntent = new Intent(WearableMainActivity.this,
SpeedPickerActivity.class);
startActivity(speedIntent);
}
});
mSaveImageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent savingIntent = new Intent(WearableMainActivity.this,
LocationSettingActivity.class);
startActivity(savingIntent);
}
});
}
private void setSpeedLimit(int speedLimit) {
mSpeedLimitText.setText(getString(R.string.speed_limit, speedLimit));
}
private void setSpeedLimit() {
SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(this);
mCurrentSpeedLimit = pref.getInt(PREFS_SPEED_LIMIT_KEY, SPEED_LIMIT_DEFAULT_MPH);
setSpeedLimit(mCurrentSpeedLimit);
}
private void setCurrentSpeed(float speed) {
mCurrentSpeed = speed;
mCurrentSpeedText.setText(String.format(getString(R.string.speed_format), speed));
adjustColor();
}
/**
* Adjusts the color of the speed based on its value relative to the speed limit.
*/
private void adjustColor() {
SpeedState state = SpeedState.ABOVE;
if (mCurrentSpeed <= mCurrentSpeedLimit - 5) {
state = SpeedState.BELOW;
} else if (mCurrentSpeed <= mCurrentSpeedLimit) {
state = SpeedState.CLOSE;
}
mCurrentSpeedText.setTextColor(getResources().getColor(state.getColor()));
}
@Override
public void onConnected(Bundle bundle) {
LocationRequest locationRequest = LocationRequest.create()
.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
.setInterval(UPDATE_INTERVAL_MS)
.setFastestInterval(FASTEST_INTERVAL_MS);
LocationServices.FusedLocationApi
.requestLocationUpdates(mGoogleApiClient, locationRequest, this)
.setResultCallback(new ResultCallback<Status>() {
@Override
public void onResult(Status status) {
if (status.getStatus().isSuccess()) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Successfully requested location updates");
}
} else {
Log.e(TAG,
"Failed in requesting location updates, "
+ "status code: "
+ status.getStatusCode() + ", message: " + status
.getStatusMessage());
}
}
});
}
@Override
public void onConnectionSuspended(int i) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "onConnectionSuspended(): connection to location client suspended");
}
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.e(TAG, "onConnectionFailed(): connection to location client failed");
}
@Override
public void onLocationChanged(Location location) {
updateSpeedVisibility(true);
setCurrentSpeed(location.getSpeed() * MPH_IN_METERS_PER_SECOND);
flashDot();
addLocationEntry(location.getLatitude(), location.getLongitude());
}
/**
* Causes the (green) dot blinks when new GPS location data is acquired.
*/
private void flashDot() {
mHandler.post(new Runnable() {
@Override
public void run() {
mDot.setVisibility(View.VISIBLE);
}
});
mDot.setVisibility(View.VISIBLE);
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
mDot.setVisibility(View.INVISIBLE);
}
}, INDICATOR_DOT_FADE_AWAY_MS);
}
/**
* Adjusts the visibility of speed indicator based on the arrival of GPS data.
*/
private void updateSpeedVisibility(boolean speedVisible) {
if (speedVisible) {
mAcquiringGps.setVisibility(View.GONE);
mCurrentSpeedText.setVisibility(View.VISIBLE);
mCurrentSpeedMphText.setVisibility(View.VISIBLE);
} else {
mAcquiringGps.setVisibility(View.VISIBLE);
mCurrentSpeedText.setVisibility(View.GONE);
mCurrentSpeedMphText.setVisibility(View.GONE);
}
}
/**
* Adds a data item to the data Layer storage
*/
private void addLocationEntry(double latitude, double longitude) {
if (!mSaveGpsLocation || !mGoogleApiClient.isConnected()) {
return;
}
mCalendar.setTimeInMillis(System.currentTimeMillis());
LocationEntry entry = new LocationEntry(mCalendar, latitude, longitude);
String path = Constants.PATH + "/" + mCalendar.getTimeInMillis();
PutDataMapRequest putDataMapRequest = PutDataMapRequest.create(path);
putDataMapRequest.getDataMap().putDouble(Constants.KEY_LATITUDE, entry.latitude);
putDataMapRequest.getDataMap().putDouble(Constants.KEY_LONGITUDE, entry.longitude);
putDataMapRequest.getDataMap()
.putLong(Constants.KEY_TIME, entry.calendar.getTimeInMillis());
PutDataRequest request = putDataMapRequest.asPutDataRequest();
Wearable.DataApi.putDataItem(mGoogleApiClient, request)
.setResultCallback(new ResultCallback<DataApi.DataItemResult>() {
@Override
public void onResult(DataApi.DataItemResult dataItemResult) {
if (!dataItemResult.getStatus().isSuccess()) {
Log.e(TAG, "AddPoint:onClick(): Failed to set the data, "
+ "status: " + dataItemResult.getStatus()
.getStatusCode());
}
}
});
}
@Override
protected void onStop() {
super.onStop();
if (mGoogleApiClient.isConnected()) {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
}
mGoogleApiClient.disconnect();
}
@Override
protected void onResume() {
super.onResume();
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mCalendar = Calendar.getInstance();
setSpeedLimit();
adjustColor();
updateRecordingIcon();
}
private void updateRecordingIcon() {
mSaveGpsLocation = LocationSettingActivity.getGpsRecordingStatusFromPreferences(this);
mSaveImageView.setImageResource(mSaveGpsLocation ? R.drawable.ic_gps_saving_grey600_96dp
: R.drawable.ic_gps_not_saving_grey600_96dp);
}
/**
* Returns {@code true} if this device has the GPS capabilities.
*/
private boolean hasGps() {
return getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS);
}
}