//Request High Accuracy Location

protected static final String TAG = "MainActivity";

/**
* Constant used in the location settings dialog.
*/
protected static final int REQUEST_CHECK_SETTINGS = 0x1;
/**
* The desired interval for location updates. Inexact. Updates may be more or
less frequent.
*/
public static final long UPDATE_INTERVAL_IN_MILLISECONDS = 10000;

/**
* The fastest rate for active location updates. Exact. Updates will never be
more frequent
* than this value.
*/
public static final long FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS =
UPDATE_INTERVAL_IN_MILLISECONDS / 2;

// Keys for storing activity state in the Bundle.

protected final static String KEY_REQUESTING_LOCATION_UPDATES = "requesting-
location-updates";
protected final static String KEY_LOCATION = "location";
protected final static String KEY_LAST_UPDATED_TIME_STRING = "last-updated-
time-string";

/**
* Provides the entry point to Google Play services.
*/
protected GoogleApiClient mGoogleApiClient;

/**
* Stores parameters for requests to the FusedLocationProviderApi.
*/
protected LocationRequest mLocationRequest;

/**
* Stores the types of location services the client is interested in using.
Used for checking
* settings to determine if the device has optimal location settings.
*/
protected LocationSettingsRequest mLocationSettingsRequest;

/**
* Represents a geographical location.
*/
protected Location mCurrentLocation;

/**
* The callback invoked when
* {@link
com.google.android.gms.location.SettingsApi#checkLocationSettings(GoogleApiClient,
* LocationSettingsRequest)} is called. Examines the
* {@link com.google.android.gms.location.LocationSettingsResult} object and
determines if
* location settings are adequate. If they are not, begins the process of
presenting a location
 * settings dialog to the user.
*/
@Override
public void onResult(LocationSettingsResult locationSettingsResult) {
final Status status = locationSettingsResult.getStatus();
switch (status.getStatusCode()) {
case LocationSettingsStatusCodes.SUCCESS:
Log.i(TAG, "All location settings are satisfied.");
//startLocationUpdates();
break;
case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
Log.i(TAG, "Location settings are not satisfied. Show the user a
dialog to" +
"upgrade location settings ");
try {
// Show the dialog by calling startResolutionForResult(), and
check the result
// in onActivityResult().
status.startResolutionForResult(MainActivity.this,
REQUEST_CHECK_SETTINGS);
} catch (IntentSender.SendIntentException e) {
Log.i(TAG, "PendingIntent unable to execute request.");
}
break;
case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
Log.i(TAG, "Location settings are inadequate, and cannot be fixed
here. Dialog " +
"not created.");
break;
}
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
// Check for the integer request code originally supplied to
startResolutionForResult().
case REQUEST_CHECK_SETTINGS:
switch (resultCode) {
case Activity.RESULT_OK:
Log.i(TAG, "User agreed to make required location settings
changes.");
startLocationUpdates();
break;
case Activity.RESULT_CANCELED:
Log.i(TAG, "User chose not to make required location
settings changes.");
break;
}
break;
}
}

/**
* Builds a GoogleApiClient. Uses the {@code #addApi} method to request the
* LocationServices API.
*/
protected synchronized void buildGoogleApiClient() {
Log.i(TAG, "Building GoogleApiClient");
 mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}

/**
* Requests location updates from the FusedLocationApi.
*/
//protected
protected void startLocationUpdates() {
LocationServices.FusedLocationApi.requestLocationUpdates(
mGoogleApiClient,
mLocationRequest,
this
).setResultCallback(new ResultCallback<Status>() {
@Override
public void onResult(Status status) {
//mRequestingLocationUpdates = true;
//setButtonsEnabledState();
}
});
}

/**
* Runs when a GoogleApiClient object successfully connects.
*/
@Override
public void onConnected(Bundle connectionHint) {
Log.i(TAG, "Connected to GoogleApiClient");

// If the initial location was never previously requested, we use

// FusedLocationApi.getLastLocation() to get it. If it was previously
requested, we store
// its value in the Bundle and check for it in onCreate(). We
// do not request it again unless the user specifically requests location
updates by pressing
// the Start Updates button.
//
// Because we cache the value of the initial location in the Bundle, it
means that if the
// user launches the activity,
// moves to a new location, and then changes the device orientation, the
original location
// is displayed as the activity is re-created.

//if (mCurrentLocation == null) {

// mCurrentLocation =
LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
// mLastUpdateTime = DateFormat.getTimeInstance().format(new Date());
// updateLocationUI();
//}
//startLocationUpdates();
}

/**
* Callback that fires when the location changes.
*/
 @Override
public void onLocationChanged(Location location) {
mCurrentLocation = location;
//mLastUpdateTime = DateFormat.getTimeInstance().format(new Date());
//updateLocationUI();
//Toast.makeText(this,
getResources().getString(R.string.location_updated_message),
// Toast.LENGTH_SHORT).show();
}

@Override
public void onConnectionSuspended(int cause) {
Log.i(TAG, "Connection suspended");
}

@Override
public void onConnectionFailed(ConnectionResult result) {
// Refer to the javadoc for ConnectionResult to see what error codes might
be returned in
// onConnectionFailed.
Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = " +
result.getErrorCode());
}

/**
* Sets up the location request. Android has two location request settings:
* {@code ACCESS_COARSE_LOCATION} and {@code ACCESS_FINE_LOCATION}. These
settings control
* the accuracy of the current location. This sample uses ACCESS_FINE_LOCATION,
as defined in
* the AndroidManifest.xml.
* <p/>
* When the ACCESS_FINE_LOCATION setting is specified, combined with a fast
update
* interval (5 seconds), the Fused Location Provider API returns location
updates that are
* accurate to within a few feet.
* <p/>
* These settings are appropriate for mapping applications that show real-time
location
* updates.
*/
protected void createLocationRequest() {
mLocationRequest = new LocationRequest();

// Sets the desired interval for active location updates. This interval is
// inexact. You may not receive updates at all if no location sources are
available, or
// you may receive them slower than requested. You may also receive updates
faster than
// requested if other applications are requesting location at a faster
interval.
mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS);

// Sets the fastest rate for active location updates. This interval is
exact, and your
// application will never receive updates faster than this value.

mLocationRequest.setFastestInterval(FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS);
 mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
}

/**
* Uses a {@link
com.google.android.gms.location.LocationSettingsRequest.Builder} to build
* a {@link com.google.android.gms.location.LocationSettingsRequest} that is
used for checking
* if a device has the needed location settings.
*/
protected void buildLocationSettingsRequest() {
LocationSettingsRequest.Builder builder = new
LocationSettingsRequest.Builder();
builder.addLocationRequest(mLocationRequest);
mLocationSettingsRequest = builder.build();
}
/**
* Check if the device's location settings are adequate for the app's needs
using the
* {@link
com.google.android.gms.location.SettingsApi#checkLocationSettings(GoogleApiClient,
* LocationSettingsRequest)} method, with the results provided through a {@code
PendingResult}.
*/
protected void checkLocationSettings() {
PendingResult<LocationSettingsResult> result =
LocationServices.SettingsApi.checkLocationSettings(
mGoogleApiClient,
mLocationSettingsRequest
);
result.setResultCallback(this);
}

//End Request High Accuracy Location