标签: rx-android

我刚刚开始使用RxJava/RxAndroid,我想知道我是否可以使用它来解决以下问题.基本上,给定一个Field,比如一个textview,一个值,一个字符串,我正在寻找一种方法来在字符串的值发生变化时自动更新textview.我不确定如何将其作为Observable实现.让我来证明一下;

String str = "Test"; //the string value
TextView textView = (TextView) findViewById(R.id.textView); //the textview

Observable o = //looking for this part. Want to observe the String str

o.subscribe(new Observer<String>() { //subscribe here looking for string changes

            @Override
            public void onCompleted() {
                System.out.println("Completed");
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onNext(String s) {
                textView.setText(s); //update the textview here
            }

        });

//here is where the string changes, it could be hardcoded, user input, or   
//anything else really, …

我仍然不明白内存泄漏是如何出现的.

我知道如果使用的东西(如单例)持有对其他的引用,则此对象不能被垃圾收集并且可用内存会关闭.

但是在这种情况下会发生什么？我使用RxBinding从单击事件创建和Observable.范围在这里,它说:

警告:创建的observable保留对{@code view}的强引用.取消订阅以免费提供此参考.

为什么这有必要？当我在onCreate中将手动监听器设置为匿名内部类时,它会引用该活动,对吧？但为什么整个activity-view-observable-subscription不能再被垃圾收集？

我对Observable.zip函数有点"estetic"问题.你这样使用它:

Observerbale.zip(
    reqA, reqB, reqC,
    (a, b, c) -> {/*deal with them*/});

请求数量等于"处理它"功能中的参数数量.现在,如果你有更多的请求,比如6,你将最终得到函数,它需要6个参数(假设它们都有不同的类型).它只是感觉不干净.有没有办法将它们包装在一个类中,例如属性？

我现在的真实问题是,我使用zip来加载设置数据:

Observable.zip(
    loadAPIMenus(),                        //1.
    databaseService.readFavorites(),       //2.
    (menuResponse, favorites) -> loadFavorites(menuResponse, favorites)) //3.
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(
        menus -> menuSubscriber.onNext(menus), //4.
        error -> menuSubscriber.onError(error));

1. 从rest api加载列表视图的项目
2. 加载这些项目的ID,这些项目在db中存储为收藏夹
3. 合并两个列表,因此最喜欢的项目是isFavorite>设置为true
4. 更新列表视图

现在不是那么糟糕.但我想在#3处增加2-3个对其他数据结束函数的请求将增长到具有太多函数参数的4行猛犸象.

我想,我可以使用Observable.zip嵌套在另一个中,但可能很危险.有没有更优雅的方式来包裹这些参数？

我很高兴看到你的建议.

让我说我有observable call rest api服务然后将结果存储在数据库中:

public Observable<Boolean> initDB() {
    return this.restApi.feedsEntityList()
        .flatMap(feedEntityList -> this.mNewsCache.saveFeeds(feedEntityList));
}

save Observable执行数据库保存,如果成功则返回true,如果发生错误则返回false:

public Observable<Boolean> saveFeeds(List<FeedEntity> feedEntity) {
   if (feedEntity != null) {
       return Observable.create(new Observable.OnSubscribe<Boolean>() {
           @Override
           public void call(Subscriber<? super Boolean> subscriber) {
               try {
                   Log.d("DB: ", "saving Feed to DB");
                   for (FeedEntity feeds : feedEntity) {
                       feeds.save();
                   }
                   subscriber.onNext(true);
                   subscriber.onCompleted();
               } catch (Exception exception) {
                   subscriber.onError(exception);
               }
           }
       });
   } else return Observable.empty();
}

在最后一个观察中,我不确定我是否正确地做到了.ie如果成功完成数据库保存操作,则返回true.否则返回false!

还有,我应该返回feedEntity是否为空？

那是对的吗？我应该如何检查observable是否返回true,false或empty Observable？

我想要实现的目标:我希望每5分钟轮询一次来自网络的资源,但只有在有观察者订阅的情况下.我使用BehaviorSubject和interval observable进行池化.我设法实现了它,但我是Rx的新手,我认为它可以做得更好.

这就是我做到的方式:

private BehaviorSubject<String> observable;
private Subscription> subscription;

public Subscription subscribe(final Action1<String> action) {
    if (observable == null) {
        observable = BehaviorSubject.create();
    }
    if (subscription == null) {
        Observable<String> source = Observable.interval(5, TimeUnit.MINUTES).map(new Func1<Long, String>() {
            @Override
            public String call(Long aLong) {
                return getDataFromServer();
            }
        }).observeOn(AndroidSchedulers.mainThread());
        subscription = source.subscribe(new Action1<String>() {

            @Override
            public void call(String s) {
                if (observable.hasObservers()) {
                    observable.onNext(s);
                } else {
                    subscription.unsubscribe();
                    subscription = null;
                }
            }
        });
    }
    return observable.subscribe(action);
}

这个想法: - 我有一个可观察的轮询源和客户可以订阅的另一个observable(使用BehaviourSubject实现 - …

是否有某种方式,通过'方式',我的意思是使用rx运算符,转换每个HashMap值(将hashmap键设置为值字段)并进入新的Hashmap或ArrList？

Observable<HashMap<String,Allergy>> observable = MyREST.getsAllergiesApi().getAllAllergiesRx();
    observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .unsubscribeOn(Schedulers.io())
            .subscribe(new Subscriber<HashMap<String, Allergy>>() {
                @Override
                public void onCompleted() {
                    Log.i(TAG,"onCompleted");
                }

                @Override
                public void onError(Throwable e) {
                    Log.i(TAG,"onError");
                }

                @Override
                public void onNext(HashMap<String, Allergy> allergies) {

                    mView.displayAllergies(allergies);
                    Log.i(TAG,"onNeXt");
                }
            });

我有一个PublishSubject注册doOnSubscribe和doOnUnsubscribe操作.如果订阅完成,则不会调用这两个操作.

private PublishSubject<Long> publishSubject;
private Subscription subscription;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);     
    publishSubject = PublishSubject.create();
    publishSubject.doOnSubscribe(new Action0() {
        @Override
        public void call() {
            Log.d("SUBJECT", "Someone subscribed.");
        }
    });
    publishSubject.doOnUnsubscribe(new Action0() {
        @Override
        public void call() {
            Log.d("SUBJECT", "Someone UNsubscribed.");
        }
    });

    Observable.interval(1, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
        @Override
        public void call(final Long tick) {
            publishSubject.onNext(tick);
        }
    });
}

@Override
protected void onResume() {
    super.onResume();
    subscription = publishSubject.subscribe(new Action1<Long>() {
        @Override
        public void call(final Long aLong) …

我想实现一个简单的场景,当观察者订阅PublishSubject时会发生某个动作.

我这样实现了:

PublishSubject<String>publishSubject=PublishSubject.create();
                publishSubject.doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        //do something
                    }
                });

                publishSubject.subscribe(new Observer<String>() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(String s) {

                }
            });
                publishSubject.onNext("xyz");

问题是Action0.call方法永远不会被调用.

这里有什么问题吗？还是有另一种方法可以做到这一点？

我正在尝试学习RxJava,我正在转换AsyncTask我必须是一个Observable/Subscriber.原始AsyncTask图像在后台加载,然后将ImageView的drawable设置为加载的图像onPostExecute.显示的图像位于recyclerview中,当列表滚动时,将为列表中的每个项目加载图像.我将它转换为Rx,但现在滚动时存在很多延迟.fetchThumbnail每次onBind调用该方法都在RecyclerView的适配器中调用.下面您将看到我的原始实现已注释掉,以及新的实现.我发现使用RxJava时内存或CPU使用率没有显着增加.我相信我也在订阅和观察正确的线程.是什么赋予了？

public class ThumbnailWorker {

    public static void fetchThumbnail(final Context context, final GalleryItem galleryItem, final int thumbId, final ThumnailFetchedListener completionListener) {

        galleryItem.thumbnail.setImageBitmap(null);
        galleryItem.progressBar.setVisibility(View.VISIBLE);

        Observable.just(MediaStore.Video.Thumbnails.getThumbnail(context.getContentResolver(),
                thumbId
                , MediaStore.Video.Thumbnails.MINI_KIND,
                null))
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        completionListener.thumbnailFetched(galleryItem, bitmap, thumbId);
                        galleryItem.progressBar.setVisibility(View.GONE);
                    }
                });


//
//        new AsyncTask<Void,Bitmap,Bitmap>() {
//
//
//            @Override
//            protected void onPreExecute() {
//                super.onPreExecute();
//                galleryItem.thumbnail.setImageBitmap(null);
//                galleryItem.progressBar.setVisibility(View.VISIBLE);
//            }
//
//            @Override …

我正在Kotlin中使用Android Archi + Retrofit + RxAndroid。从服务器获得响应时，我需要更新Data对象。但是livedata.addSource的onChanged没有调用。

我正在从Git代码获取帮助：-https: //github.com/shahbazahmed1269/AndroidGithubIssues

这是我在Kotlin中的代码：-

class LoginRepository : BaseRepository() {

fun callLoginApi(data: HashMap<String, String>): LiveData<LoginResponse> {

    val liveData: MutableLiveData<LoginResponse> = MutableLiveData<LoginResponse>()

//        val call = mApiService.getLoginUser(data)

    mApiService.getLoginUser(data)
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    { user ->
                        liveData.value = user
                        Log.e("response", user.toString())
                    },
                    { error ->
                        liveData.value = LoginResponse(error = error.localizedMessage)
                        Log.e("Error", error.message)

                    })
    return liveData
}
}


open class LoginViewModel : ViewModel() {
lateinit var loginResponse : MediatorLiveData<LoginResponse>
lateinit var loginRepo:LoginRepository;
init {
    loginResponse = MediatorLiveData<LoginResponse>()
    loginRepo = LoginRepository() …