位置更新

我需要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

回答

相关问题