Android 工作经理如何处理FusedLocationProviderClient中的位置更新？

首先，我是个十足的机器人呆子。我们已经寻找了一段时间的解决方案，但到目前为止还没有找到任何正确方向的有用提示。这通常可能是由问题本身的性质造成的，因为问题本身非常特殊

下面的工作代码基于位于的代码实验室

不过，我想知道，既然在一些参考资料中提到它是现在首选的方式，那么您将如何基于Android的Work Manager而不是带有持续通知的服务来做类似的事情呢

public class TrackerService extends Service {

    @Override
    public void onCreate() {
        super.onCreate();
        requestLocationUpdates();
    }

    private void requestLocationUpdates() {
        LocationRequest request = new LocationRequest();
        request.setInterval(5 * 60 * 1000);
        request.setFastestInterval(30 * 1000);
        request.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        FusedLocationProviderClient client = LocationServices.getFusedLocationProviderClient(this);
        int permission = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION);
        if (permission == PackageManager.PERMISSION_GRANTED) {
            client.requestLocationUpdates(request, new LocationCallback() {
                @Override
                public void onLocationResult(LocationResult locationResult) {
                    Location location = locationResult.getLastLocation();
                    if (location != null) {
                        Log.d(TAG, "location update " + location);
                    }
                }
            }, null);
        }
    }
}

根据我在web项目中的经验，上述代码基于FusedLocationProviderClient建立了一个“侦听器”。一旦有新的位置更新，它将调用带有相应位置结果的

onLocationResult

到目前为止，我对工作经理的了解是，您可以使用工作经理设置一个工人，使其

doWork（）

一次或定期。就像一个cron工作一样有效

---

我不明白的是，如果后台没有正在运行的服务，工作人员和位置更新请求将在哪里启动？它们是如何协同工作的？

这里我创建了一个演示：

MyWorker.java

public class MyWorker extends Worker {

    private static final String TAG = "MyWorker";

    /**
     * The desired interval for location updates. Inexact. Updates may be more or less frequent.
     */
    private static final long UPDATE_INTERVAL_IN_MILLISECONDS = 10000;

    /**
     * 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 =
            UPDATE_INTERVAL_IN_MILLISECONDS / 2;
    /**
     * The current location.
     */
    private Location mLocation;

    /**
     * Provides access to the Fused Location Provider API.
     */
    private FusedLocationProviderClient mFusedLocationClient;

    private Context mContext;
    /**
     * Callback for changes in location.
     */
    private LocationCallback mLocationCallback;

    public MyWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
        mContext = context;
    }

    @NonNull
    @Override
    public Result doWork() {
        Log.d(TAG, "doWork: Done");

                mFusedLocationClient = LocationServices.getFusedLocationProviderClient(mContext);
                mLocationCallback = new LocationCallback() {
                    @Override
                    public void onLocationResult(LocationResult locationResult) {
                        super.onLocationResult(locationResult);
                    }
                };

                LocationRequest mLocationRequest = new LocationRequest();
                mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS);
                mLocationRequest.setFastestInterval(FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS);
                mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

                try {
                    mFusedLocationClient
                            .getLastLocation()
                            .addOnCompleteListener(new OnCompleteListener<Location>() {
                                @Override
                                public void onComplete(@NonNull Task<Location> task) {
                                    if (task.isSuccessful() && task.getResult() != null) {
                                        mLocation = task.getResult();
                                        Log.d(TAG, "Location : " + mLocation);
                                        mFusedLocationClient.removeLocationUpdates(mLocationCallback);
                                    } else {
                                        Log.w(TAG, "Failed to get location.");
                                    }
                                }
                            });
                } catch (SecurityException unlikely) {
                    Log.e(TAG, "Lost location permission." + unlikely);
                }

                try {
                    mFusedLocationClient.requestLocationUpdates(mLocationRequest, null);
                } catch (SecurityException unlikely) {
                    //Utils.setRequestingLocationUpdates(this, false);
                    Log.e(TAG, "Lost location permission. Could not request updates. " + unlikely);
                }

        } catch (ParseException ignored) {

        }

        return Result.success();
    }
}

---

希望这会有帮助。如果你有什么问题，一定要告诉我。谢谢。

让我们澄清一下，您将在扩展自Worker类的类中启动位置更新请求，并且您将运行自己的doWork函数。看看这个例子——Thx@VadimEksler——代码会出现在我的默认活动中吗？如果我定期运行一个worker，它会不会为位置更新注册多个回调？1）扩展worker的单独类MyLocationWorker。然后像

PeriodicWorkRequest myWorkRequest=newperiodicworkrequest.Builder（MyLocationWorker.class，30，TimeUnit.MINUTES）.build（）一样启动它2）当你得到定位结果时，你需要删除回调。非常有趣。我看到它甚至可以在重新启动后工作。因此，这似乎是一条路要走。我必须进一步发挥我的想法。Thx提供的解决方案。这回答了我的问题。谢谢。这个答案需要更多的投票，它解决了很多人的具体问题，包括我的问题。@PratikButaniAndroidDev目前正在研究一种方法，但是为了提示一个新的位置更新，使用WorkManager中的ListenableWorker with
concurrent futures
，您在
doWork（）中打印了一些日志吗
？它将在后台调用。最小间隔为15分钟。
PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(MyWorker.class, 15, TimeUnit.MINUTES)
                            .addTag(TAG)
                            .build();
WorkManager.getInstance().enqueueUniquePeriodicWork("Location", ExistingPeriodicWorkPolicy.REPLACE, periodicWork);