Java tutorial
/** * Copyright 2017 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.peptrack.gps.locationupdatesforegroundservice; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.ServiceConnection; import android.content.SharedPreferences; import android.location.Location; import android.os.IBinder; import android.preference.PreferenceManager; import android.support.v4.content.LocalBroadcastManager; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.Manifest; import android.content.pm.PackageManager; import android.net.Uri; import android.provider.Settings; import android.support.annotation.NonNull; import android.support.design.widget.Snackbar; import android.support.v4.app.ActivityCompat; import android.view.View; import android.widget.Button; import android.widget.Toast; import android.os.AsyncTask; import com.google.android.gms.common.api.GoogleApiClient; import com.google.android.gms.common.api.ApiException; import com.google.android.gms.common.api.ResolvableApiException; import com.google.android.gms.location.LocationRequest; import com.google.android.gms.location.LocationServices; import com.google.android.gms.location.LocationSettingsRequest; import com.google.android.gms.location.LocationSettingsResponse; import com.google.android.gms.location.LocationSettingsStatusCodes; import com.google.android.gms.location.SettingsClient; import com.google.android.gms.tasks.OnFailureListener; import com.google.android.gms.tasks.OnSuccessListener; import android.content.IntentSender; /** * The only activity in this sample. * * Note: for apps running in the background on "O" devices (regardless of the targetSdkVersion), * location may be computed less frequently than requested when the app is not in the foreground. * Apps that use a foreground service - which involves displaying a non-dismissable * notification - can bypass the background location limits and request location updates as before. * * This sample uses a long-running bound and started service for location updates. The service is * aware of foreground status of this activity, which is the only bound client in * this sample. After requesting location updates, when the activity ceases to be in the foreground, * the service promotes itself to a foreground service and continues receiving location updates. * When the activity comes back to the foreground, the foreground service stops, and the * notification associated with that foreground service is removed. * * While the foreground service notification is displayed, the user has the option to launch the * activity from the notification. The user can also remove location updates directly from the * notification. This dismisses the notification and stops the service. */ public class MainActivity extends AppCompatActivity implements SharedPreferences.OnSharedPreferenceChangeListener { private static final String TAG = MainActivity.class.getSimpleName(); // Used in checking for runtime permissions. private static final int REQUEST_PERMISSIONS_LOCATION_REQUEST_CODE = 34; private static final int REQUEST_PERMISSIONS_INTERNET_REQUEST_CODE = 35; // The BroadcastReceiver used to listen from broadcasts from the service. private MyReceiver myReceiver; // A reference to the service used to get location updates. private LocationUpdatesService mService = null; // Tracks the bound state of the service. private boolean mBound = false; /** * Provides access to the Location Settings API. */ private SettingsClient mSettingsClient; /** * 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. */ private LocationSettingsRequest mLocationSettingsRequest; /** * Stores parameters for requests to the FusedLocationProviderApi. */ private LocationRequest mLocationRequest; /** * Constant used in the location settings dialog. */ private static final int REQUEST_CHECK_SETTINGS = 0x1; /** * The desired interval for location updates. Inexact. Updates may be more or less frequent. */ private static final long UPDATE_INTERVAL_IN_MILLISECONDS = 15000; /** * The fastest rate for active location updates. Updates will never be more frequent * than this value. */ private static final long FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS = 15000; // UI elements. private Button mRequestLocationUpdatesButton; private Button mRemoveLocationUpdatesButton; private GoogleApiClient mGoogleApiClient; // Monitors the state of the connection to the service. private final ServiceConnection mServiceConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { LocationUpdatesService.LocalBinder binder = (LocationUpdatesService.LocalBinder) service; mService = binder.getService(); mBound = true; } @Override public void onServiceDisconnected(ComponentName name) { mService = null; mBound = false; } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); myReceiver = new MyReceiver(); setContentView(R.layout.activity_main); /* Check that the user hasn't revoked permissions by going to Settings. if (Utils.requestingLocationUpdates(this)) { if (!checkLocationPermissions()) { requestLocationPermissions(); if (!checkInternetPermissions()) { requestInternetPermissions(); } } }*/ if (checkLocationPermissions() && checkInternetPermissions()) { createLocationRequest(); buildLocationSettingsRequest(); } else { //required permission not granted } } @Override protected void onStart() { super.onStart(); PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(this); mRequestLocationUpdatesButton = (Button) findViewById(R.id.request_location_updates_button); mRemoveLocationUpdatesButton = (Button) findViewById(R.id.remove_location_updates_button); mRequestLocationUpdatesButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { if (checkLocationPermissions() && checkInternetPermissions()) { startLocationUpdates(); //mService.requestLocationUpdates(); } else { //required permission not granted } } }); mRemoveLocationUpdatesButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { mService.removeLocationUpdates(); } }); // Restore the state of the buttons when the activity (re)launches. setButtonsState(Utils.requestingLocationUpdates(this)); // Bind to the service. If the service is in foreground mode, this signals to the service // that since this activity is in the foreground, the service can exit foreground mode. bindService(new Intent(this, LocationUpdatesService.class), mServiceConnection, Context.BIND_AUTO_CREATE); } @Override protected void onResume() { super.onResume(); LocalBroadcastManager.getInstance(this).registerReceiver(myReceiver, new IntentFilter(LocationUpdatesService.ACTION_BROADCAST)); } @Override protected void onPause() { LocalBroadcastManager.getInstance(this).unregisterReceiver(myReceiver); super.onPause(); } @Override protected void onStop() { if (mBound) { // Unbind from the service. This signals to the service that this activity is no longer // in the foreground, and the service can respond by promoting itself to a foreground // service. unbindService(mServiceConnection); mBound = false; } PreferenceManager.getDefaultSharedPreferences(this).unregisterOnSharedPreferenceChangeListener(this); super.onStop(); } /** * 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. */ private 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. */ private void buildLocationSettingsRequest() { LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder(); builder.addLocationRequest(mLocationRequest); mLocationSettingsRequest = builder.build(); } /** * Requests location updates from the FusedLocationApi. Note: we don't call this unless location * runtime permission has been granted. */ private void startLocationUpdates() { try { // Begin by checking if the device has the necessary location settings. mSettingsClient = LocationServices.getSettingsClient(MainActivity.this); mSettingsClient.checkLocationSettings(mLocationSettingsRequest) .addOnSuccessListener(this, new OnSuccessListener<LocationSettingsResponse>() { @Override public void onSuccess(LocationSettingsResponse locationSettingsResponse) { Log.i(TAG, "All location settings are satisfied."); //noinspection MissingPermission //mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.myLooper()); mService.requestLocationUpdates(); } }).addOnFailureListener(this, new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { int statusCode = ((ApiException) e).getStatusCode(); switch (statusCode) { case LocationSettingsStatusCodes.RESOLUTION_REQUIRED: Log.i(TAG, "Location settings are not satisfied. Attempting to upgrade " + "location settings "); try { // Show the dialog by calling startResolutionForResult(), and check the // result in onActivityResult(). ResolvableApiException rae = (ResolvableApiException) e; rae.startResolutionForResult(MainActivity.this, REQUEST_CHECK_SETTINGS); } catch (IntentSender.SendIntentException sie) { Log.i(TAG, "PendingIntent unable to execute request."); } break; case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE: String errorMessage = "Location settings are inadequate, and cannot be " + "fixed here. Fix in Settings."; Log.e(TAG, errorMessage); Toast.makeText(MainActivity.this, errorMessage, Toast.LENGTH_LONG).show(); //mRequestingLocationUpdates = false; } } }); } catch (Exception e) { String err = e.getMessage(); Log.e(TAG, err); } } /** * Returns the current state of the permissions needed. */ private boolean checkLocationPermissions() { return PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION); } private boolean checkInternetPermissions() { return PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(this, Manifest.permission.INTERNET); } private void requestLocationPermissions() { boolean shouldProvideRationale = ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION); // Provide an additional rationale to the user. This would happen if the user denied the // request previously, but didn't check the "Don't ask again" checkbox. if (shouldProvideRationale) { Log.i(TAG, "Displaying permission rationale to provide additional context."); Snackbar.make(findViewById(R.id.activity_main), R.string.permission_rationale_location, Snackbar.LENGTH_INDEFINITE).setAction(R.string.ok, new View.OnClickListener() { @Override public void onClick(View view) { // Request permission ActivityCompat.requestPermissions(MainActivity.this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, REQUEST_PERMISSIONS_LOCATION_REQUEST_CODE); } }).show(); } else { Log.i(TAG, "Requesting permission"); // Request permission. It's possible this can be auto answered if device policy // sets the permission in a given state or the user denied the permission // previously and checked "Never ask again". ActivityCompat.requestPermissions(MainActivity.this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, REQUEST_PERMISSIONS_LOCATION_REQUEST_CODE); } } private void requestInternetPermissions() { boolean shouldProvideRationale = ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.INTERNET); // Provide an additional rationale to the user. This would happen if the user denied the // request previously, but didn't check the "Don't ask again" checkbox. if (shouldProvideRationale) { Log.i(TAG, "Displaying permission rationale to provide additional context."); Snackbar.make(findViewById(R.id.activity_main), R.string.permission_rationale_internet, Snackbar.LENGTH_INDEFINITE).setAction(R.string.ok, new View.OnClickListener() { @Override public void onClick(View view) { // Request permission ActivityCompat.requestPermissions(MainActivity.this, new String[] { Manifest.permission.INTERNET }, REQUEST_PERMISSIONS_INTERNET_REQUEST_CODE); } }).show(); } else { Log.i(TAG, "Requesting permission"); // Request permission. It's possible this can be auto answered if device policy // sets the permission in a given state or the user denied the permission // previously and checked "Never ask again". ActivityCompat.requestPermissions(MainActivity.this, new String[] { Manifest.permission.INTERNET }, REQUEST_PERMISSIONS_INTERNET_REQUEST_CODE); } } /** * Callback received when a permissions request has been completed. */ @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { Log.i(TAG, "onRequestPermissionResult"); if (requestCode == REQUEST_PERMISSIONS_LOCATION_REQUEST_CODE || requestCode == REQUEST_PERMISSIONS_INTERNET_REQUEST_CODE) { if (grantResults.length <= 0) { // If user interaction was interrupted, the permission request is cancelled and you // receive empty arrays. Log.i(TAG, "User interaction was cancelled."); } else if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { // Permission was granted. mService.requestLocationUpdates(); } else { // Permission denied. setButtonsState(false); Snackbar.make(findViewById(R.id.activity_main), R.string.permission_denied_explanation, Snackbar.LENGTH_INDEFINITE).setAction(R.string.settings, new View.OnClickListener() { @Override public void onClick(View view) { // Build intent that displays the App settings screen. Intent intent = new Intent(); intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS); Uri uri = Uri.fromParts("package", BuildConfig.APPLICATION_ID, null); intent.setData(uri); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(intent); } }).show(); } } } /** * Receiver for broadcasts sent by {@link LocationUpdatesService}. */ private class MyReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { Location location = intent.getParcelableExtra(LocationUpdatesService.EXTRA_LOCATION); if (location != null) { double latitude = location.getLatitude(); double longitude = location.getLongitude(); double altitude = 0; if (location.hasAltitude()) altitude = location.getAltitude(); APIParams apiParams = new APIParams(latitude, longitude, 0, altitude); new PepAPITask().execute(apiParams); Toast.makeText(MainActivity.this, Utils.getLocationText(location), Toast.LENGTH_SHORT).show(); } } } @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) { // Update the buttons state depending on whether location updates are being requested. if (s.equals(Utils.KEY_REQUESTING_LOCATION_UPDATES)) { setButtonsState(sharedPreferences.getBoolean(Utils.KEY_REQUESTING_LOCATION_UPDATES, false)); } } private void setButtonsState(boolean requestingLocationUpdates) { if (requestingLocationUpdates) { mRequestLocationUpdatesButton.setEnabled(false); mRemoveLocationUpdatesButton.setEnabled(true); } else { mRequestLocationUpdatesButton.setEnabled(true); mRemoveLocationUpdatesButton.setEnabled(false); } } } class APIParams { double latitude; double longitude; double speed; double altitude; APIParams(double latitude, double longitude, double speed, double altitude) { this.latitude = latitude; this.longitude = longitude; this.speed = speed; this.altitude = altitude; } } class PepAPITask extends AsyncTask<APIParams, Void, String> { private Exception exception; protected void onPreExecute() { //progressBar.setVisibility(View.VISIBLE); //responseView.setText(""); } protected String doInBackground(APIParams... apiParam) { //String email = emailText.getText().toString(); // Do some validation here String responseText; try { String apiUrl = "http://peptrack.com/api/v1.0/data/push?t=31&k=shmnnb1ggkazbtqea3832q&s=0&a=" + apiParam[0].latitude + "&b=" + apiParam[0].longitude + "&c=" + apiParam[0].altitude + "&d=" + apiParam[0].speed + "&x=&y=&z=&r=&p="; responseText = Utils.getResponseText(apiUrl, 8000); } catch (Exception e) { //return e.getMessage(); responseText = "Error"; } return responseText; } protected void onPostExecute(String response) { if (response == null || response == "Error") { response = "THERE WAS AN ERROR"; } //else { //try { //JSONObject object = (JSONObject) new JSONTokener(response).nextValue(); //String requestID = object.getString("requestId");int likelihood = object.getInt("likelihood"); //JSONArray photos = object.getJSONArray("photos"); //} catch (JSONException e) { //e.printStackTrace(); //} //} } }