Home | History | Annotate | Download | only in speedtracker 
      1 /*
      2  * Copyright (C) 2014 Google Inc. All Rights Reserved.
      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.speedtracker;
     18 
     19 import com.google.android.gms.common.ConnectionResult;
     20 import com.google.android.gms.common.api.GoogleApiClient;
     21 import com.google.android.gms.common.api.ResultCallback;
     22 import com.google.android.gms.common.api.Status;
     23 import com.google.android.gms.location.LocationListener;
     24 import com.google.android.gms.location.LocationRequest;
     25 import com.google.android.gms.location.LocationServices;
     26 import com.google.android.gms.wearable.DataApi;
     27 import com.google.android.gms.wearable.PutDataMapRequest;
     28 import com.google.android.gms.wearable.PutDataRequest;
     29 import com.google.android.gms.wearable.Wearable;
     30 
     31 import android.Manifest;
     32 import android.annotation.SuppressLint;
     33 import android.app.AlertDialog;
     34 import android.content.DialogInterface;
     35 import android.content.Intent;
     36 import android.content.SharedPreferences;
     37 import android.content.pm.PackageManager;
     38 import android.location.Location;
     39 import android.os.Bundle;
     40 import android.os.Handler;
     41 import android.preference.PreferenceManager;
     42 import android.support.annotation.NonNull;
     43 import android.support.v4.app.ActivityCompat;
     44 import android.support.wearable.activity.WearableActivity;
     45 import android.util.Log;
     46 import android.view.View;
     47 import android.widget.ImageView;
     48 import android.widget.TextView;
     49 
     50 import com.example.android.wearable.speedtracker.common.Constants;
     51 import com.example.android.wearable.speedtracker.common.LocationEntry;
     52 
     53 import java.util.Calendar;
     54 import java.util.concurrent.TimeUnit;
     55 
     56 /**
     57  * The main activity for the wearable app. User can pick a speed limit, and after this activity
     58  * obtains a fix on the GPS, it starts reporting the speed. In addition to showing the current
     59  * speed, if user's speed gets close to the selected speed limit, the color of speed turns yellow
     60  * and if the user exceeds the speed limit, it will turn red. In order to show the user that GPS
     61  * location data is coming in, a small green dot keeps on blinking while GPS data is available.
     62  */
     63 public class WearableMainActivity extends WearableActivity implements
     64         GoogleApiClient.ConnectionCallbacks,
     65         GoogleApiClient.OnConnectionFailedListener,
     66         ActivityCompat.OnRequestPermissionsResultCallback,
     67         LocationListener {
     68 
     69     private static final String TAG = "WearableActivity";
     70 
     71     private static final long UPDATE_INTERVAL_MS = TimeUnit.SECONDS.toMillis(5);
     72     private static final long FASTEST_INTERVAL_MS = TimeUnit.SECONDS.toMillis(5);
     73 
     74     private static final float MPH_IN_METERS_PER_SECOND = 2.23694f;
     75 
     76     private static final int SPEED_LIMIT_DEFAULT_MPH = 45;
     77 
     78     private static final long INDICATOR_DOT_FADE_AWAY_MS = 500L;
     79 
     80     // Request codes for changing speed limit and location permissions.
     81     private static final int REQUEST_PICK_SPEED_LIMIT = 0;
     82 
     83     // Id to identify Location permission request.
     84     private static final int REQUEST_GPS_PERMISSION = 1;
     85 
     86     // Shared Preferences for saving speed limit and location permission between app launches.
     87     private static final String PREFS_SPEED_LIMIT_KEY = "SpeedLimit";
     88 
     89     private Calendar mCalendar;
     90 
     91     private TextView mSpeedLimitTextView;
     92     private TextView mSpeedTextView;
     93     private ImageView mGpsPermissionImageView;
     94     private TextView mCurrentSpeedMphTextView;
     95     private TextView mGpsIssueTextView;
     96     private View mBlinkingGpsStatusDotView;
     97 
     98     private String mGpsPermissionNeededMessage;
     99     private String mAcquiringGpsMessage;
    100 
    101     private int mSpeedLimit;
    102     private float mSpeed;
    103 
    104     private boolean mGpsPermissionApproved;
    105 
    106     private boolean mWaitingForGpsSignal;
    107 
    108     private GoogleApiClient mGoogleApiClient;
    109 
    110     private Handler mHandler = new Handler();
    111 
    112     private enum SpeedState {
    113         BELOW(R.color.speed_below), CLOSE(R.color.speed_close), ABOVE(R.color.speed_above);
    114 
    115         private int mColor;
    116 
    117         SpeedState(int color) {
    118             mColor = color;
    119         }
    120 
    121         int getColor() {
    122             return mColor;
    123         }
    124     }
    125 
    126     @Override
    127     protected void onCreate(Bundle savedInstanceState) {
    128         super.onCreate(savedInstanceState);
    129 
    130         Log.d(TAG, "onCreate()");
    131 
    132 
    133         setContentView(R.layout.main_activity);
    134 
    135         /*
    136          * Enables Always-on, so our app doesn't shut down when the watch goes into ambient mode.
    137          * Best practice is to override onEnterAmbient(), onUpdateAmbient(), and onExitAmbient() to
    138          * optimize the display for ambient mode. However, for brevity, we aren't doing that here
    139          * to focus on learning location and permissions. For more information on best practices
    140          * in ambient mode, check this page:
    141          * https://developer.android.com/training/wearables/apps/always-on.html
    142          */
    143         setAmbientEnabled();
    144 
    145         mCalendar = Calendar.getInstance();
    146 
    147         // Enables app to handle 23+ (M+) style permissions.
    148         mGpsPermissionApproved =
    149             ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    150                     == PackageManager.PERMISSION_GRANTED;
    151 
    152         mGpsPermissionNeededMessage = getString(R.string.permission_rationale);
    153         mAcquiringGpsMessage = getString(R.string.acquiring_gps);
    154 
    155 
    156         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    157         mSpeedLimit = sharedPreferences.getInt(PREFS_SPEED_LIMIT_KEY, SPEED_LIMIT_DEFAULT_MPH);
    158 
    159         mSpeed = 0;
    160 
    161         mWaitingForGpsSignal = true;
    162 
    163 
    164         /*
    165          * If this hardware doesn't support GPS, we warn the user. Note that when such device is
    166          * connected to a phone with GPS capabilities, the framework automatically routes the
    167          * location requests from the phone. However, if the phone becomes disconnected and the
    168          * wearable doesn't support GPS, no location is recorded until the phone is reconnected.
    169          */
    170         if (!hasGps()) {
    171             Log.w(TAG, "This hardware doesn't have GPS, so we warn user.");
    172             new AlertDialog.Builder(this)
    173                     .setMessage(getString(R.string.gps_not_available))
    174                     .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
    175                         @Override
    176                         public void onClick(DialogInterface dialog, int id) {
    177                             dialog.cancel();
    178                         }
    179                     })
    180                     .setOnDismissListener(new DialogInterface.OnDismissListener() {
    181                         @Override
    182                         public void onDismiss(DialogInterface dialog) {
    183                             dialog.cancel();
    184                         }
    185                     })
    186                     .setCancelable(false)
    187                     .create()
    188                     .show();
    189         }
    190 
    191 
    192         setupViews();
    193 
    194         mGoogleApiClient = new GoogleApiClient.Builder(this)
    195                 .addApi(LocationServices.API)
    196                 .addApi(Wearable.API)
    197                 .addConnectionCallbacks(this)
    198                 .addOnConnectionFailedListener(this)
    199                 .build();
    200     }
    201 
    202     @Override
    203     protected void onPause() {
    204         super.onPause();
    205         if ((mGoogleApiClient != null) && (mGoogleApiClient.isConnected()) &&
    206                 (mGoogleApiClient.isConnecting())) {
    207             LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
    208             mGoogleApiClient.disconnect();
    209         }
    210 
    211     }
    212 
    213     @Override
    214     protected void onResume() {
    215         super.onResume();
    216         if (mGoogleApiClient != null) {
    217             mGoogleApiClient.connect();
    218         }
    219     }
    220 
    221     private void setupViews() {
    222         mSpeedLimitTextView = (TextView) findViewById(R.id.max_speed_text);
    223         mSpeedTextView = (TextView) findViewById(R.id.current_speed_text);
    224         mCurrentSpeedMphTextView = (TextView) findViewById(R.id.current_speed_mph);
    225 
    226         mGpsPermissionImageView = (ImageView) findViewById(R.id.gps_permission);
    227         mGpsIssueTextView = (TextView) findViewById(R.id.gps_issue_text);
    228         mBlinkingGpsStatusDotView = findViewById(R.id.dot);
    229 
    230         updateActivityViewsBasedOnLocationPermissions();
    231     }
    232 
    233     public void onSpeedLimitClick(View view) {
    234         Intent speedIntent = new Intent(WearableMainActivity.this,
    235                 SpeedPickerActivity.class);
    236         startActivityForResult(speedIntent, REQUEST_PICK_SPEED_LIMIT);
    237     }
    238 
    239     public void onGpsPermissionClick(View view) {
    240 
    241         if (!mGpsPermissionApproved) {
    242 
    243             Log.i(TAG, "Location permission has NOT been granted. Requesting permission.");
    244 
    245             // On 23+ (M+) devices, GPS permission not granted. Request permission.
    246             ActivityCompat.requestPermissions(
    247                     this,
    248                     new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
    249                     REQUEST_GPS_PERMISSION);
    250         }
    251     }
    252 
    253     /**
    254      * Adjusts the visibility of views based on location permissions.
    255      */
    256     private void updateActivityViewsBasedOnLocationPermissions() {
    257 
    258         /*
    259          * If the user has approved location but we don't have a signal yet, we let the user know
    260          * we are waiting on the GPS signal (this sometimes takes a little while). Otherwise, the
    261          * user might think something is wrong.
    262          */
    263         if (mGpsPermissionApproved && mWaitingForGpsSignal) {
    264 
    265             // We are getting a GPS signal w/ user permission.
    266             mGpsIssueTextView.setText(mAcquiringGpsMessage);
    267             mGpsIssueTextView.setVisibility(View.VISIBLE);
    268             mGpsPermissionImageView.setImageResource(R.drawable.ic_gps_saving_grey600_96dp);
    269 
    270             mSpeedTextView.setVisibility(View.GONE);
    271             mSpeedLimitTextView.setVisibility(View.GONE);
    272             mCurrentSpeedMphTextView.setVisibility(View.GONE);
    273 
    274         } else if (mGpsPermissionApproved) {
    275 
    276             mGpsIssueTextView.setVisibility(View.GONE);
    277 
    278             mSpeedTextView.setVisibility(View.VISIBLE);
    279             mSpeedLimitTextView.setVisibility(View.VISIBLE);
    280             mCurrentSpeedMphTextView.setVisibility(View.VISIBLE);
    281             mGpsPermissionImageView.setImageResource(R.drawable.ic_gps_saving_grey600_96dp);
    282 
    283         } else {
    284 
    285             // User needs to enable location for the app to work.
    286             mGpsIssueTextView.setVisibility(View.VISIBLE);
    287             mGpsIssueTextView.setText(mGpsPermissionNeededMessage);
    288             mGpsPermissionImageView.setImageResource(R.drawable.ic_gps_not_saving_grey600_96dp);
    289 
    290             mSpeedTextView.setVisibility(View.GONE);
    291             mSpeedLimitTextView.setVisibility(View.GONE);
    292             mCurrentSpeedMphTextView.setVisibility(View.GONE);
    293         }
    294     }
    295 
    296     private void updateSpeedInViews() {
    297 
    298         if (mGpsPermissionApproved) {
    299 
    300             mSpeedLimitTextView.setText(getString(R.string.speed_limit, mSpeedLimit));
    301             mSpeedTextView.setText(String.format(getString(R.string.speed_format), mSpeed));
    302 
    303             // Adjusts the color of the speed based on its value relative to the speed limit.
    304             SpeedState state = SpeedState.ABOVE;
    305             if (mSpeed <= mSpeedLimit - 5) {
    306                 state = SpeedState.BELOW;
    307             } else if (mSpeed <= mSpeedLimit) {
    308                 state = SpeedState.CLOSE;
    309             }
    310 
    311             mSpeedTextView.setTextColor(getResources().getColor(state.getColor()));
    312 
    313             // Causes the (green) dot blinks when new GPS location data is acquired.
    314             mHandler.post(new Runnable() {
    315                 @Override
    316                 public void run() {
    317                     mBlinkingGpsStatusDotView.setVisibility(View.VISIBLE);
    318                 }
    319             });
    320             mBlinkingGpsStatusDotView.setVisibility(View.VISIBLE);
    321             mHandler.postDelayed(new Runnable() {
    322                 @Override
    323                 public void run() {
    324                     mBlinkingGpsStatusDotView.setVisibility(View.INVISIBLE);
    325                 }
    326             }, INDICATOR_DOT_FADE_AWAY_MS);
    327         }
    328     }
    329 
    330     @SuppressLint("MissingPermission")
    331     @Override
    332     public void onConnected(Bundle bundle) {
    333 
    334         Log.d(TAG, "onConnected()");
    335         requestLocation();
    336 
    337 
    338     }
    339 
    340     private void requestLocation() {
    341         Log.d(TAG, "requestLocation()");
    342 
    343         /*
    344          * mGpsPermissionApproved covers 23+ (M+) style permissions. If that is already approved or
    345          * the device is pre-23, the app uses mSaveGpsLocation to save the user's location
    346          * preference.
    347          */
    348         if (mGpsPermissionApproved) {
    349 
    350             LocationRequest locationRequest = LocationRequest.create()
    351                     .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
    352                     .setInterval(UPDATE_INTERVAL_MS)
    353                     .setFastestInterval(FASTEST_INTERVAL_MS);
    354 
    355             LocationServices.FusedLocationApi
    356                     .requestLocationUpdates(mGoogleApiClient, locationRequest, this)
    357                     .setResultCallback(new ResultCallback<Status>() {
    358 
    359                         @Override
    360                         public void onResult(Status status) {
    361                             if (status.getStatus().isSuccess()) {
    362                                 if (Log.isLoggable(TAG, Log.DEBUG)) {
    363                                     Log.d(TAG, "Successfully requested location updates");
    364                                 }
    365                             } else {
    366                                 Log.e(TAG,
    367                                         "Failed in requesting location updates, "
    368                                                 + "status code: "
    369                                                 + status.getStatusCode() + ", message: " + status
    370                                                 .getStatusMessage());
    371                             }
    372                         }
    373                     });
    374         }
    375     }
    376 
    377     @Override
    378     public void onConnectionSuspended(int i) {
    379         Log.d(TAG, "onConnectionSuspended(): connection to location client suspended");
    380 
    381         LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
    382     }
    383 
    384     @Override
    385     public void onConnectionFailed(ConnectionResult connectionResult) {
    386         Log.e(TAG, "onConnectionFailed(): " + connectionResult.getErrorMessage());
    387     }
    388 
    389     @Override
    390     public void onLocationChanged(Location location) {
    391         Log.d(TAG, "onLocationChanged() : " + location);
    392 
    393 
    394         if (mWaitingForGpsSignal) {
    395             mWaitingForGpsSignal = false;
    396             updateActivityViewsBasedOnLocationPermissions();
    397         }
    398 
    399         mSpeed = location.getSpeed() * MPH_IN_METERS_PER_SECOND;
    400         updateSpeedInViews();
    401         addLocationEntry(location.getLatitude(), location.getLongitude());
    402     }
    403 
    404     /*
    405      * Adds a data item to the data Layer storage.
    406      */
    407     private void addLocationEntry(double latitude, double longitude) {
    408         if (!mGpsPermissionApproved || !mGoogleApiClient.isConnected()) {
    409             return;
    410         }
    411         mCalendar.setTimeInMillis(System.currentTimeMillis());
    412         LocationEntry entry = new LocationEntry(mCalendar, latitude, longitude);
    413         String path = Constants.PATH + "/" + mCalendar.getTimeInMillis();
    414         PutDataMapRequest putDataMapRequest = PutDataMapRequest.create(path);
    415         putDataMapRequest.getDataMap().putDouble(Constants.KEY_LATITUDE, entry.latitude);
    416         putDataMapRequest.getDataMap().putDouble(Constants.KEY_LONGITUDE, entry.longitude);
    417         putDataMapRequest.getDataMap()
    418                 .putLong(Constants.KEY_TIME, entry.calendar.getTimeInMillis());
    419         PutDataRequest request = putDataMapRequest.asPutDataRequest();
    420         request.setUrgent();
    421         Wearable.DataApi.putDataItem(mGoogleApiClient, request)
    422                 .setResultCallback(new ResultCallback<DataApi.DataItemResult>() {
    423                     @Override
    424                     public void onResult(DataApi.DataItemResult dataItemResult) {
    425                         if (!dataItemResult.getStatus().isSuccess()) {
    426                             Log.e(TAG, "AddPoint:onClick(): Failed to set the data, "
    427                                     + "status: " + dataItemResult.getStatus()
    428                                     .getStatusCode());
    429                         }
    430                     }
    431                 });
    432     }
    433 
    434     /**
    435      * Handles user choices for both speed limit and location permissions (GPS tracking).
    436      */
    437     @Override
    438     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    439 
    440         if (requestCode == REQUEST_PICK_SPEED_LIMIT) {
    441             if (resultCode == RESULT_OK) {
    442                 // The user updated the speed limit.
    443                 int newSpeedLimit =
    444                         data.getIntExtra(SpeedPickerActivity.EXTRA_NEW_SPEED_LIMIT, mSpeedLimit);
    445 
    446                 SharedPreferences sharedPreferences =
    447                         PreferenceManager.getDefaultSharedPreferences(this);
    448                 SharedPreferences.Editor editor = sharedPreferences.edit();
    449                 editor.putInt(WearableMainActivity.PREFS_SPEED_LIMIT_KEY, newSpeedLimit);
    450                 editor.apply();
    451 
    452                 mSpeedLimit = newSpeedLimit;
    453 
    454                 updateSpeedInViews();
    455             }
    456         }
    457     }
    458 
    459     /**
    460      * Callback received when a permissions request has been completed.
    461      */
    462     @Override
    463     public void onRequestPermissionsResult(
    464             int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    465 
    466         Log.d(TAG, "onRequestPermissionsResult(): " + permissions);
    467 
    468 
    469         if (requestCode == REQUEST_GPS_PERMISSION) {
    470             Log.i(TAG, "Received response for GPS permission request.");
    471 
    472             if ((grantResults.length == 1)
    473                     && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
    474                 Log.i(TAG, "GPS permission granted.");
    475                 mGpsPermissionApproved = true;
    476 
    477                 if(mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
    478                     requestLocation();
    479                 }
    480 
    481             } else {
    482                 Log.i(TAG, "GPS permission NOT granted.");
    483                 mGpsPermissionApproved = false;
    484             }
    485 
    486             updateActivityViewsBasedOnLocationPermissions();
    487 
    488         }
    489     }
    490 
    491     /**
    492      * Returns {@code true} if this device has the GPS capabilities.
    493      */
    494     private boolean hasGps() {
    495         return getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS);
    496     }
    497 }