public class LoginActivity extends BaseActivity implements LoginView {
Handler handler = new Handler();
@Override
protected int getLayoutId() {
return R.layout.activity_main;
}
@Override
protected void initDatas() {
/**
* 1、初始的RxJava
*/
// rxJavaDemo();
/**
* 2、简洁版的RxJava
*/
// rxJavaDemo_concise();
/**
* 3、用操作符来进行操作Rxjava
*/
// rxJavaDemo_operator();
/**
* 4、深的操作符号(*****)
*/
// rxJavaDemo_operator_more();
/**
* 5、更深的操作符号(主要是讲 onComplete()和onError() )
* 这两个函数用来通知订阅者，被观察的对象将停止发送数据以及为什么停止（成功的完成或者出错了）。
*
* 还有RxJava 线程调度的问题
*/
// rxJavaDemo_operator_more_more();
/***
* Rxjava 在Android 中应用
*/
rxJavaDemo_operator_more_more_android();
}
/**
* 接着要介绍的就是AndroidObservable，它提供了跟多的功能来配合Android的生命周期。
* bindActivity()和bindFragment()方法默认使用AndroidSchedulers.mainThread()来执行观察者代码，这两个方法会在Activity或者Fragment结束的时候通知被观察者停止发出新的消息。
*/
private void rxJavaDemo_operator_more_more_android() {
}
private void rxJavaDemo_operator_more_more() {
Subscription a = Observable.just("这个在的线程是:").subscribeOn(Schedulers.io())//订阅者发生在 工作线程中 即io
.observeOn(AndroidSchedulers.mainThread())//发生在主线程中 即 观察者 在 main线程中
.subscribe(s -> showMessagers(s));
//停止当前的操作 RxJava的另外一个好处就是它处理unsubscribing的时候，会停止整个调用链。
// 如果你使用了一串很复杂的操作符，调用unsubscribe将会在他当前执行的地方终止。不需要做任何额外的工作！
// a.unsubscribe();
new View(this).postDelayed(() -> a.unsubscribe(), 2000);
}
/**
* 相比更加详细的操作符学习
*/
private void rxJavaDemo_operator_more() {
// Observable.from()方法，它接收一个集合作为输入，然后每次输出一个元素给subscriber：
// ArrayList<String> list = new ArrayList<>();
//
// list.add("d");
// list.add("ddddd");
// String[] arrays = {"d", "b"};
// Observable.from(list).subscribe(s -> showMessagers(s));
//将list数据给观察者 这个为比较复杂的写法了
getDbDatas().subscribe(listData -> {
Observable.from(listData).subscribe(listSring -> showMessagers(listSring));
});
/**
* 这个是用flatmap写的 相对来说要简单很多
*/
getDbDatas().flatMap(new Func1<List<String>, Observable<String>>() {
@Override
public Observable<String> call(List<String> strings) {
return Observable.from(strings);
}
}).subscribe(s -> showMessagers(s));
/**
* 用兰博啦来写就更简单了
*/
getDbDatas().flatMap(listData -> Observable.from(listData)).subscribe(listString -> showMessagers(listString));
/**
* 接着前面的例子，现在我不想打印URL了，而是要打印收到的每个网站的标题。
* 问题来了，我的方法每次只能传入一个URL，并且返回值不是一个String，
* 而是一个输出String的Observabl对象。使用flatMap()可以简单的解决这个问题。
*/
getDbDatas().flatMap(stringList -> Observable.from(stringList)).flatMap(stringData -> getTitle(stringData)).subscribe(title -> showMessagers(title));
/**
* filter()输出和输入相同的元素，并且会过滤掉那些不满足检查条件的。
* take()如果我们只想要最多5个结果：
* doOnNext()允许我们在每次输出一个元素之前做一些额外的事情，比如这里的保存标题。
*/
getDbDatas().flatMap(stringList -> Observable.from(stringList)).flatMap(stringData -> getTitle(stringData)).filter(title -> title != null).take(5).doOnNext(title -> saveTitle(title)).subscribe(title -> showMessagers(title));
}
/**
* 保存标题等操作
*/
public void saveTitle(String t) {
}
/**
* 根据 string 串来进行查询Title
*/
Observable<String> getTitle(String URL) {
String data = "data";
return Observable.just(data);
}
/**
* 返回Observable<String>数据
*
* @return
*/
public Observable<String> getStringData() {
return Observable.just("数据");
}
/**
* 得到Observable<List<String>>对象
*
* @return
*/
public Observable<List<String>> getDbDatas() {
List listData = new ArrayList();
listData.add("a");
listData.add("b");
listData.add("c");
listData.add("d");
return Observable.just(listData);
}
/**
* 用RxJava中操作符来进行操作 map就是来进行对observable改变的 map()操作符就是用于变换Observable对象的
*/
private void rxJavaDemo_operator() {
Observable.just("这个是操作符的操作哦").map(s -> s + "demo").subscribe(s -> showMessagers(s));
Observable.just("操作符号哦222222").map(s -> s.hashCode()).subscribe(s -> showMessagers(s.toString()));//中间对 observable 进行改变 变成hash 值
Observable.just("操作符号哦3333复杂的").map(s -> s.hashCode()).map(i -> Integer.toString(i)).subscribe(s -> showMessagers(s));//连续两个map进行转接
}
/**
* 简洁版本的 RxJava
*/
private void rxJavaDemo_concise() {
/**
* 比如Observable.just就是用来创建只发出一个事件就结束的Observable对象，上面创建Observable对象的代码可以简化为一行
*/
Observable<String> myObservable = Observable.just("这个是只发出一个事件的-->这个是RxJava");
/**
* 接下来看看如何简化Subscriber，上面的例子中，我们其实并不关心OnComplete和OnError，我们只需要在onNext的时候做一些处理，这时候就可以使用Action1类。
*/
Action1<String> onNextAction = new Action1<String>() {
@Override
public void call(String s) {
//相当于Subscriber中的接受
Toast.makeText(LoginActivity.this, s, Toast.LENGTH_SHORT).show();
}
};
myObservable.subscribe(onNextAction);
//其实上面的完全可以写成这样的哦
Observable.just("结合到一起的写法").subscribe(new Action1<String>() {
@Override
public void call(String s) {
Toast.makeText(LoginActivity.this, s, Toast.LENGTH_SHORT).show();
}
});
//或者用lambda表达式的写法 这个就更简单了哦~~~~
Observable.just("lambda表达式的写法 看看星星").subscribe(s -> Toast.makeText(LoginActivity.this, s, Toast.LENGTH_SHORT).show());
}
/**
* Observable 被观察者 Subscribers 观察者
*/
private void rxJavaDemo() {
/**
* 创建观察者模式 --> 被观察者
*
* 一个Observable可以发出零个或者多个事件，知道结束或者出错。
* 每发出一个事件，就会调用它的Subscriber的onNext方法，最后调用Subscriber.onNext()或者Subscriber.onError()结束。
*/
Observable<String> myObservable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("这是RxJava");
subscriber.onCompleted();
}
});
/**
* 接着我们创建一个Subscriber来处理Observable对象发出的字符串。
*
*/
Subscriber<String> mySubscriber = new Subscriber<String>() {
@Override
public void onCompleted() {
Toast.makeText(LoginActivity.this, "完成啦...", Toast.LENGTH_SHORT).show();
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Toast.makeText(LoginActivity.this, s, Toast.LENGTH_SHORT).show();
}
};
/**
* 这里subscriber仅仅就是打印observable发出的字符串。
* 通过subscribe函数就可以将我们定义的myObservable对象和mySubscriber对象关联起来，这样就完成了subscriber对observable的订阅。
*/
myObservable.subscribe(mySubscriber);
}
@Override
protected void initListeners() {
}
@Override
protected void initViews(Bundle savedInstanceState) {
}
@Override
public void showMessagers(String message) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
}