位置更新

我需要ActivityRecognition後得到的用戶位置（由fusedlocation API）檢測用戶狀態（其中要求每3分鐘），像IN_VEHICLE，ON_FOOT，跑步等位置更新

在每個事件我需要定期間隔後的用戶位置例如：

如果用戶仍然然後setInterval(5*60*60*1000);並檢查下一個位置更新不在5小時之前。但ActivityRecognation會每3分鐘打一次電話。

如果用戶正在運行然後setInterval(2*60*1000);並檢查下一次位置更新不在/ 2分鐘後。但ActivityRecognation會每3分鐘打一次電話。

如果用戶正在運行，則每隔1分鐘發送一次位置如果用戶正在開車，則每15分鐘發送一次位置。

我試圖在onConnected布爾值false在類級別爲false和true。但它總是變成真實的，因爲整個意圖服務在3分鐘後被調用。

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. 
       }

問題我有

ActivityRecognation獲取用戶狀態，每3分鐘，但直到它從另一個ActivityRecognation國家不應該進入startLocationFirst布爾和不斷更新的位置爲套內startLocationFirst

這裏是IntentService With 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); 

    } 

}

來源

2017-04-26 Ritu

此問題不適用於官方消息。任何人都可以回答 – androidXP

我在向上面添加幾行代碼後執行此代碼。

首先我在一流水平的IntentService因爲DectectedActivity.getType()回報INT聲明靜態INT。 static int detectedActivity;
然後在我檢查其是否相同的狀態，最後像這樣if (activity.getConfidence() >= 75 && activity.getType()!=detectedActivity)

這it.Thanks到@Pablo巴克斯特誰給了我某種邏輯來apply.I測試這對IntentService，但我需要在服務上測試它，所以我可以更新locations.Will更新。

來源

2017-05-06 19:17:08 androidXP

編輯

這裏是一個更好的例子，只用你的代碼已經在上面提供：註冊ActivityRecognitionApi時

使用此服務：

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); 
    } 
}

，這將是IntentService使用而不是使用您正在使用的AsyncTask：

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()); 
      } 
     } 
    } 
}

只要在onHandleIntent內調用了此意向服務，就可以處理阻止網絡請求。

我修改了handleDetectedActivity代碼，以便在每次活動更新時都不會發生新的位置更新。

首先，我不建議你使用IntentService你現在的樣子，因爲一旦退出onHandleIntent，因爲你是靠回調，這將導致很多問題，該服務將被殺死。所有這些都應該被放入Service。

至於處理基於活動識別的位置更新，我確實找到了這個很好的庫，它簡化了這一點，並且非常易於使用。https://github.com/mrmans0n/smart-location-lib

以下是如何根據活動結果使用庫位置更新的示例。

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. 
    } 
});

這應該被投進onStart功能Service，基於您提供的意圖演員onStartCommand處理的變化。您還可以使用此庫來獲取最後一個已知位置，並獲得一個修復程序。

最後一件事，我建議你遠離AsyncTask，如果你將上下文傳遞給它。請使用IntentService，因爲onHandleIntent函數在後臺線程中運行，您可以使用IntentService的上下文來執行您需要的任何任務。當您開始IntentService時，您可以將Location對象作爲額外的目標傳遞給目標。

來源

2017-05-04 17:09:28

你可能是對的。但是我已經在github上檢查了這個庫，並且我們不想使用任何額外的lib.This將通過一些邏輯修復，而沒有任何額外的庫 – androidXP

您的代碼邏輯說，檢查最後的活動是否不等於當前。如果活動改變，那麼進入範圍。我是對的？請清除我，如果我錯了 – androidXP

如在代碼中使用lastActivity（DetectedActivity），如果它與最後一樣。所以它將是空的，因爲它沒有初始化並且在它之後放置值 – androidXP

回答

相關問題