Standortaktualisierung auf Basis von Gerätezustand

Question

Ich brauche Lage (Von fusedlocation API) erhalten von Benutzer nach ActivityRecognition Benutzerzustand erkennen (was alle 3 Minuten Anrufe), wie IN_VEHICLE, ON_FOOT, Laufen usw.

Auf jeder Veranstaltung Ich brauche Benutzer Ort nach regelmäßigen Intervall Zum Beispiel:

wenn Benutzer immer noch dann setInterval(5*60*60*1000); und überprüfen Sie für den nächsten Standort Update in nicht vor 5 Stunden. Aber ActivityRecognation ruft alle 3 Minuten auf.

Wenn der Benutzer läuft, dann setInterval(2*60*1000); und nach dem nächsten Standort-Update suchen in nicht vor/Nach 2 Minuten. Aber ActivityRecognation ruft alle 3 Minuten auf.

Wenn der Benutzer läuft, dann senden Sie den Standort alle 1 Minuten wenn der Benutzer fährt, dann senden Sie den Standort alle 15 Minuten.

Ich habe versucht, Boolean False in onConnected auf Klassenebene falsch und wahr zu setzen. Aber es wird immer wahr, weil der ganze Intent-Dienst nach 3 Minuten aufgerufen wird.

if (startLocationFirst){ 
requestLocatonSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); 
    LocationAPIclient.connect();// RequestLocation and GoogleAPIClient won't call until device comes from another ActivityRecognation State running,walking etc. And keep Updating location every 5 hours. 
       } 

Ausgabe Ich bin Strom mit

• ActivityRecognation Ruft Benutzerstatus alle 3 Minuten, aber es sollte nicht in startLocationFirst boolean eintreten, wenn es von einem anderen ActivityRecognation Staat kommt und halten Standort Aktualisierung als innerhalb startLocationFirst gesetzt
Hier

ist IntentService Mit FusedLocation

public class Activity_Recognized_Service extends IntentService implements GoogleApiClient.OnConnectionFailedListener, GoogleApiClient.ConnectionCallbacks, LocationListener { 
    /** 
    * Creates an IntentService. Invoked by your subclass's constructor. 
    * 
    * @param name Used to name the worker thread, important only for debugging. 
    */ 
    public static final String TAG = "###RECOGNISED SRVCE###"; 
    Timer timer; 
    GoogleApiClient LocationAPIclient; 
    LocationRequest mLocationRequest; 
    Location mCurrentLocation; 
    boolean startLocationFirst=true; 


    public Activity_Recognized_Service() { 
     super("Activity_Recognized_Service"); 
    } 

    public Activity_Recognized_Service(String name) { 
     super(name); 
    } 

    @Override 
    protected void onHandleIntent(@Nullable Intent intent) { 
     Log.d(TAG, "On Handle Intent"); 
     if (ActivityRecognitionResult.hasResult(intent)) { 
      Log.d(TAG, "ActivityRecognition Has Result"); 
      ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent); 
      handleDetectedActivities(result.getProbableActivities()); 
      Navigation_Drawer nav = new Navigation_Drawer(); 
      nav.UserMovementResult(result); 

     } 
    } 

    @Override 
    public void onCreate() { 
     super.onCreate(); 
     Log.d(TAG,"On Create Calling"); 
     if (LocationAPIclient == null) { 
      Log.d(TAG, "Location API is NULL Value Of This "); 
      LocationAPIclient = new GoogleApiClient.Builder(this) 
        .addApi(LocationServices.API) 
        .addConnectionCallbacks(this) 
        .addOnConnectionFailedListener(this) 
        .build(); 
     } 

    } 

    private void handleDetectedActivities(List<DetectedActivity> probableActivities) { 

     for (DetectedActivity activity : probableActivities) { 
      switch (activity.getType()) { 
       case DetectedActivity.IN_VEHICLE: 
        Log.d(TAG, "In Vehicle " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("In Vehicle"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 
         requestLocatonSetting(10*60*1000,8*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
         LocationAPIclient.connect(); 
         if (startLocationFirst){ 
          Log.d(TAG,"Start Location Update For Car"); 
         } 
        } 
        break; 
       case DetectedActivity.ON_BICYCLE: 
        Log.d(TAG, "On Bicycle " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("On Bicycle"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 
         requestLocatonSetting(7*60*1000,5*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
         LocationAPIclient.connect(); 
        } 
        break; 
       case DetectedActivity.ON_FOOT: 
        Log.d(TAG, "On Foot " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("On Foot"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 
        } 
        break; 
       case DetectedActivity.RUNNING: 
        Log.d(TAG, "On Running " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("Running"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 
         requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
         LocationAPIclient.connect(); 
        } 
        break; 
       case DetectedActivity.STILL: 
        Log.d(TAG, "On Still " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("Still"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 

          requestLocatonSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
          // requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
          LocationAPIclient.connect(); 


        } 
        break; 
       case DetectedActivity.TILTING: 
        Log.d(TAG, "On Tilting " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("Tilting"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 

         requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
         LocationAPIclient.connect(); 
        } 
        break; 
       case DetectedActivity.WALKING: 
        Log.d(TAG, "On Walking " + activity.getConfidence()); 
        if (activity.getConfidence() >= 75) { 
         //Send Notification To User 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
         builder.setContentText("Let's Walk"); 
         builder.setSmallIcon(R.drawable.elaxer_x); 
         builder.setContentTitle("Elaxer"); 
         NotificationManagerCompat.from(this).notify(0, builder.build()); 
         requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         LocationAPIclient.connect(); 

        } 
        break; 
       case DetectedActivity.UNKNOWN: 
        Log.d(TAG, "UnKnown " + activity.getConfidence()); 
        break; 
      } 
     } 
    } 

    public void setTimer(int Minutes) { 
     Log.d(TAG, "=================================================="); 
     Log.d(TAG, "Set Timeer Starts It will Run Every " + Minutes); 
     int MilliSeconds = 60000 * Minutes; 
     final Handler handler = new Handler(); 
     timer = new Timer(); 
     TimerTask doAsynchronousTask = new TimerTask() { 
      @Override 
      public void run() { 
       handler.post(new Runnable() { 
        public void run() { 
         try { 
          //CODE THAT YOU WANT TO EXECUTE AT GIVEN INTERVAL 


         } catch (Exception e) { 
          // TODO Auto-generated catch block 
         } 
        } 
       }); 
      } 
     }; 
     timer.schedule(doAsynchronousTask, 0, MilliSeconds); 
     Log.d(TAG, "=================================================="); 
    } 


    @Override 
    public void onConnected(@Nullable Bundle bundle) { 
     Log.d(TAG, "On Connected Running"); 
     if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
      return; 
     } 
     mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(LocationAPIclient); 
     if (mCurrentLocation!=null){ 
      Log.d(TAG,"Last Known Location Is not Null "); 
      new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy())); 
     } 
     else { 
      Log.d(TAG,"Last Known Location Is NULL Start Location Updates"); 
      LocationServices.FusedLocationApi.requestLocationUpdates(LocationAPIclient,mLocationRequest,this); 
     } 

    } 

    @Override 
    public void onConnectionSuspended(int i) { 

    } 

    @Override 
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { 

    } 

    @Override 
    public void onLocationChanged(Location location) { 
     Log.d(TAG,"On Location Changed Calling"); 
     mCurrentLocation=location; 
     new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy())); 
     Log.d(TAG,"Stopping Location Update"); 
     // LocationServices.FusedLocationApi.removeLocationUpdates(LocationAPIclient,this); 
    } 

    public void requestLocatonSetting(int Interval,int FastestInterval,int LocationAccuracy){ 
     mLocationRequest=new LocationRequest(); 
     mLocationRequest.setInterval(Interval); 
     mLocationRequest.setFastestInterval(FastestInterval); 
     mLocationRequest.setPriority(LocationAccuracy); 

    } 

} 

Answer 1

Ich führe diesen Code nach dem Hinzufügen von ein paar Zeilen zum gleichen Code wie oben.

• Zuerst erkläre ich static int auf Klassenebene in IntentService weil DectectedActivity.getType() Rückkehr int. static int detectedActivity;
• Dann wird bei i überprüfen, ob seine gleichen Zustand wie zuletzt ähnliche if (activity.getConfidence() >= 75 && activity.getType()!=detectedActivity)

das ist it.Thanks zu @Pablo Baxter, der mir eine Art von Logik apply.I gab dies auf IntentService getestet, aber ich muss Testen Sie es auf Service, damit ich Standorte aktualisieren kann. Wird bald aktualisiert.

Answer 2

EDIT

Hier ist ein besseres Beispiel nur mit dem Code Sie oben zur Verfügung gestellt haben:

Verwenden Sie diesen Dienst, wenn Ihr ActivityRecognitionApi Registrierung:

public class LocationUpdateService extends Service implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener { 

    public static final String TAG = "###RECOGNISED SRVCE###"; 

    private GoogleApiClient apiClient; 
    private PendingIntent pendingIntent; 
    private DetectedActivity lastActivity; 

    @Nullable 
    @Override 
    public IBinder onBind(Intent intent) { 
     return null; 
    } 

    @Override 
    public void onCreate() { 
     apiClient = new GoogleApiClient.Builder(this) 
       .addApi(LocationServices.API) 
       .addConnectionCallbacks(this) 
       .addOnConnectionFailedListener(this) 
       .build(); 

     apiClient.connect(); 
     pendingIntent = PendingIntent.getService(this, 1, new Intent(this, YourIntentService.class), PendingIntent.FLAG_UPDATE_CURRENT); 
    } 

    @Override 
    public int onStartCommand(Intent intent, int flag, int startId) { 
     Log.d(TAG, "onStartCommand"); 
     if (ActivityRecognitionResult.hasResult(intent)) { 
      Log.d(TAG, "ActivityRecognition Has Result"); 
      ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent); 
      handleDetectedActivity(result); 

      /* You should really use LocalBroadcastManager to send events out to an activity for UI updates */ 

//   Navigation_Drawer nav = new Navigation_Drawer(); 
//   nav.UserMovementResult(result); 
     } 
     return START_STICKY; 
    } 

    @Override 
    public void onConnected(@Nullable Bundle bundle) { 
     Log.d(TAG, "On Connected Running"); 
     if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
      return; 
     } 
     Location location = LocationServices.FusedLocationApi.getLastLocation(apiClient); 
     if (location!=null){ 
      Log.d(TAG,"Last Known Location Is not Null "); 
      Intent intent = new Intent(this, YourIntentService.class).putExtra("lastKnown", location); 
      startService(intent); 

      /* No more need for this! */ 
//   new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy())); 
     } 
     else { 
      Log.d(TAG,"Last Known Location Is NULL Start Location Updates"); 
      updateLocationSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); 
//   LocationServices.FusedLocationApi.requestLocationUpdates(apiClient,mLocationRequest,this); 
     } 
    } 

    @Override 
    public void onConnectionSuspended(int i) { 

    } 

    @Override 
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { 

    } 

    private void handleDetectedActivity(ActivityRecognitionResult result) { 
     DetectedActivity mostProbableActivity = result.getMostProbableActivity(); 
     switch (result.getMostProbableActivity().getType()) { 
      case DetectedActivity.IN_VEHICLE: 
//     Log.d(TAG, "In Vehicle " + activity.getConfidence()); 
       if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) { 
        //Send Notification To User 
//      NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//      builder.setContentText("In Vehicle"); 
//      builder.setSmallIcon(R.drawable.elaxer_x); 
//      builder.setContentTitle("Elaxer"); 
//      NotificationManagerCompat.from(this).notify(0, builder.build()); 
        //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST 
        if (apiClient.isConnected()) { 
         updateLocationSetting(10 * 60 * 1000, 8 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         lastActivity = mostProbableActivity; 
        } 
       } 
       break; 
      case DetectedActivity.ON_BICYCLE: 
       Log.d(TAG, "On Bicycle " + mostProbableActivity.getConfidence()); 
       if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) { 
        //Send Notification To User 
//     NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//     builder.setContentText("On Bicycle"); 
//     builder.setSmallIcon(R.drawable.elaxer_x); 
//     builder.setContentTitle("Elaxer"); 
//     NotificationManagerCompat.from(this).notify(0, builder.build()); 
        if (apiClient.isConnected()) { 
         updateLocationSetting(7 * 60 * 1000, 5 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         lastActivity = mostProbableActivity; 
        } 
       } 
       break; 

      case DetectedActivity.ON_FOOT: 
       Log.d(TAG, "On Foot " + mostProbableActivity.getConfidence()); 
       if (mostProbableActivity.getConfidence() >= 75) { 
        DetectedActivity nextHighest = result.getProbableActivities().get(1); 
        if (nextHighest.getType() == DetectedActivity.RUNNING && nextHighest != lastActivity) { 
         Log.d(TAG, "On Running " + mostProbableActivity.getConfidence()); 
         //Send Notification To User 
//      NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//      builder.setContentText("Running"); 
//      builder.setSmallIcon(R.drawable.elaxer_x); 
//      builder.setContentTitle("Elaxer"); 
//      NotificationManagerCompat.from(this).notify(0, builder.build()); 
         if (apiClient.isConnected()) { 
          updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
          lastActivity = nextHighest; 
         } 
        } 
        else if (nextHighest.getConfidence() >= 75 && nextHighest != lastActivity) { 
         Log.d(TAG, "On Walking " + mostProbableActivity.getConfidence()); 
         //Send Notification To User 
//      NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//      builder.setContentText("Let's Walk"); 
//      builder.setSmallIcon(R.drawable.elaxer_x); 
//      builder.setContentTitle("Elaxer"); 
//      NotificationManagerCompat.from(this).notify(0, builder.build()); 

         if (apiClient.isConnected()) { 
          updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
          lastActivity = nextHighest; 
         } 
        } 
        //Send Notification To User 
//     NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//     builder.setContentText("On Foot"); 
//     builder.setSmallIcon(R.drawable.elaxer_x); 
//     builder.setContentTitle("Elaxer"); 
//     NotificationManagerCompat.from(this).notify(0, builder.build()); 
       } 
       break; 
      case DetectedActivity.STILL: 
       Log.d(TAG, "On Still " + mostProbableActivity.getConfidence()); 
       if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) { 
        //Send Notification To User 
//     NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//     builder.setContentText("Still"); 
//     builder.setSmallIcon(R.drawable.elaxer_x); 
//     builder.setContentTitle("Elaxer"); 
//     NotificationManagerCompat.from(this).notify(0, builder.build()); 

        if (apiClient.isConnected()) { 
         updateLocationSetting(5 * 60 * 60 * 1000, 3 * 60 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         lastActivity = mostProbableActivity; 
        } 
       } 
       break; 
      case DetectedActivity.TILTING: 
       Log.d(TAG, "On Tilting " + mostProbableActivity.getConfidence()); 
       if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) { 
        //Send Notification To User 
//     NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//     builder.setContentText("Tilting"); 
//     builder.setSmallIcon(R.drawable.elaxer_x); 
//     builder.setContentTitle("Elaxer"); 
//     NotificationManagerCompat.from(this).notify(0, builder.build()); 

        if (apiClient.isConnected()) { 
         updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
         lastActivity = mostProbableActivity; 
        } 
       } 
       break; 
//   case DetectedActivity.WALKING: 
//    Log.d(TAG, "On Walking " + mostProbableActivity.getConfidence()); 
//    if (mostProbableActivity.getConfidence() >= 75) { 
//     //Send Notification To User 
//     NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
//     builder.setContentText("Let's Walk"); 
//     builder.setSmallIcon(R.drawable.elaxer_x); 
//     builder.setContentTitle("Elaxer"); 
//     NotificationManagerCompat.from(this).notify(0, builder.build()); 
// 
//     if (apiClient.isConnected()) { 
//      updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds 
//     } 
//    } 
//    break; 
      case DetectedActivity.UNKNOWN: 
       Log.d(TAG, "UnKnown " + mostProbableActivity.getConfidence()); 
       lastActivity = mostProbableActivity; 
       break; 
     } 
    } 

    private void updateLocationSetting(int Interval, int FastestInterval, int LocationAccuracy) { 
     LocationRequest request = new LocationRequest(); 
     request.setInterval(Interval); 
     request.setFastestInterval(FastestInterval); 
     request.setPriority(LocationAccuracy); 
     if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_DENIED) { 
      //TODO DO SOMETHING HERE! 
      return; 
     } 
     LocationServices.FusedLocationApi.requestLocationUpdates(apiClient, request, pendingIntent); 
    } 
} 

Und das wäre die IntentService anstelle der von Ihnen verwendeten AsyncTask zu verwenden:

public class YourIntentService extends IntentService { 

    public YourIntentService() { 
     super("YOUR_INTENT_SERVICE"); 
    } 

    @Override 
    protected void onHandleIntent(@Nullable Intent intent) { 
     if (intent != null) { 
      if (LocationResult.hasResult(intent)) { 
       LocationResult result = LocationResult.extractResult(intent); 
       Location location = result.getLastLocation(); 
       Log.d("YourIntentService", "Got new location: " + location); 
      } 
      else if (intent.hasExtra("lastKnown")) { 
       Location location = intent.getParcelableExtra("lastKnown"); 
       Log.d("YourIntentService", "Got last known location: " + location); 
      } 
      else if (LocationAvailability.hasLocationAvailability(intent)) { 
       LocationAvailability locationAvailability = LocationAvailability.extractLocationAvailability(intent); 
       Log.d("YourIntentService", "Location Availability: " + locationAvailability.isLocationAvailable()); 
      } 
     } 
    } 
} 

Dieser Intent-Dienst kann blockierende Netzwerkanforderungen verarbeiten, solange sie innerhalb der onHandleIntent-Klasse aufgerufen werden.

Ich habe den Code handleDetectedActivity ein bisschen geändert, so dass bei jedem Aktivitätsupdate eine neue Standortaktualisierung nicht auftritt.

---

Zunächst einmal, ich würde nicht vorschlagen, dass Sie verwenden, um eine IntentService so, wie Sie jetzt sind, wie der Dienst getötet werden, sobald es onHandleIntent verlässt, die eine Menge Probleme verursachen würde, da Sie auf Rückrufe setzen. All dies sollte stattdessen in eine Service gelegt werden.

Für die Handhabung von Standortaktualisierungen basierend auf Aktivitätserkennung habe ich diese nette Bibliothek gefunden, die das vereinfacht und ziemlich einfach zu verwenden ist.https://github.com/mrmans0n/smart-location-lib

Hier ist ein Beispiel für die Verwendung der Bibliothek mit Standortaktualisierungen basierend auf den Aktivitätsergebnissen.

SmartLocation.with(this).location(new LocationBasedOnActivityProvider(new LocationBasedOnActivityProvider.LocationBasedOnActivityListener() { 
    @Override 
    public LocationParams locationParamsForActivity(DetectedActivity detectedActivity) { 
     if (detectedActivity.getConfidence() >= 75) { 
      LocationParams.Builder builder = new LocationParams.Builder(); 
      switch (detectedActivity.getType()) { 
       case DetectedActivity.IN_VEHICLE: 
        builder.setInterval(/*Interval*/) 
          .setAccuracy(/*Locaiton Accuracy*/); 
        break; 

       case DetectedActivity.ON_BICYCLE: 
        /* So on and so forth.... */ 

        break; 
      } 
      return builder.build(); 
     } 
     return null; 
    } 
})).start(new OnLocationUpdatedListener() { 
    @Override 
    public void onLocationUpdated(Location location) { 
     //Do what you need here. 
    } 
}); 

Dies sollte in eine Service in der onStart Funktion, mit onStartCommand Handhabung Änderungen auf den Vorsatz Extras auf Basis fallen gelassen werden Sie zur Verfügung stellen. Sie können diese Bibliothek auch verwenden, um den letzten bekannten Speicherort abzurufen und um einen einzelnen Fix zu erhalten.

Eine letzte Sache, würde ich empfehlen Sie weg von der AsyncTask, wenn Sie Kontexte daran übergeben. Verwenden Sie stattdessen IntentService, da die onHandleIntent-Funktion in einem Hintergrundthread ausgeführt wird, und Sie können den IntentService-Kontext verwenden, um alle Aufgaben auszuführen, die Sie damit benötigen. Sie können das Location Objekt als Extra in der Absicht übergeben, wenn Sie Ihre IntentService starten.