从RxJava链中设置变量

Question

我正在使用ReactiveLocation库。基本上，我想在4秒内获得一个足够准确的位置。如果在此期间未收到足够精度的位置，但其他位置已返回最高精度的位置。

一旦接收到足够准确的位置，则返回该位置并完成可观测。

我会发布我正在尝试的代码。我可能，也可能，以错误的方式进行。

LocationRequest request = LocationRequest.create()
            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
            .setFastestInterval(FASTEST_UPDATE_INTERVAL)
            .setSmallestDisplacement(MIN_DISTANCE_UPDATE_INTERVAL);

    if ( expirationSeconds != null )
        request.setExpirationDuration(TimeUnit.SECONDS.toMillis(expirationSeconds));

    ReactiveLocationProvider locationProvider = new ReactiveLocationProvider(context);
    Observable<Location> observable = locationProvider.getUpdatedLocation(request)
                .doOnNext(new Action1<Location>() {
                    @Override
                    public void call(Location location) {
                        if ( mostAccurateLocation == null )
                            mostAccurateLocation = location;

                        if ( location.getAccuracy() < mostAccurateLocation.getAccuracy() )
                            mostAccurateLocation = location;
                    }
                })
                .filter(new Func1<Location, Boolean>() {
                    @Override
                    public Boolean call(Location location) {
                        return location.getAccuracy() < sufficientAccuracy ;
                    }
                });

    if ( expirationSeconds != null )
        observable = observable.timeout( expirationSeconds, TimeUnit.SECONDS, Observable.just(mostAccurateLocation), backgroundThread );

    return observable.firstOrDefault(mostAccurateLocation)
                     .doOnNext(new Action1<Location>() {
                        @Override
                        public void call(Location location) {
                            lastLocation = location;
                        }
                    });

Answer 1

好的，我找到问题了。超时开始了，但很明显，超时启动的可观察对象使用了mostAccurateLocation变量，就像创建可观察对象时一样。

为了解决这个问题，我使用了可观察的。延迟模式，这样只会创建可观察的

    if ( expirationSeconds != null ) {
        Observable<Location> mostAccurateLocationObservable = Observable.defer(new Func0<Observable<Location>>() {
            @Override
            public Observable<Location> call() {
                return Observable.just(mostAccurateLocation);
            }
        });

        observable = observable.timeout( expirationSeconds, TimeUnit.SECONDS, mostAccurateLocationObservable, backgroundThread );
    }