Hướng dẫn Upload Source Android lên Github

• Đăng nhập github trên Android Studio
• Chọn VCS -> Import -> Share Github
• Đặt tên cho project -> share -> thành công
• Nếu lỗi

Thì vào Settings xóa remote đi

Và vào command xóa

• Nếu lỗi

Thì lên github xóa repository

• Nếu lỗi

Đổi tài khoản lại

• Nếu commit không có file. Thì cứ add thêm folder và push lên tiếp.

• Thay đổi đường dẫn qua Bitbucket để push lên Bitbucket

  

Bài 7: Operator Filter (Lọc danh sách)

• Đặc điểm khi sử dụng

  • Cần lọc trong danh sách dữ liệu
  • Lọc với 1 điều kiện nào đó

• Ví dụ

package team.kiti.rxjava2_android.operators.map;

import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.View;


import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Predicate;
import team.kiti.rxjava2_android.BaseActivity;
import team.kiti.rxjava2_android.R;

public class FilterExampleActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_filter_example);

        doSomeWork();
    }

    private void doSomeWork(){
        Observable.just(1, 2, 3, 4, 5, 6)
                /*Lọc*/
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 2;
                    }
                }).subscribe(getObserver());
    }

    private Observer<Integer> getObserver(){
        return new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
    }

}

D/OKE: onNext: 3
D/OKE: onNext: 4
D/OKE: onNext: 5
D/OKE: onNext: 6

Bài 6: Operator Flatmap (Phát ra lỗi)

• Đặc điểm khi sử dụng

  • Flatmap trả về Observable.
  • Flatmap có thể không phát ra item nào,  phát ra 1 item, phát ra nhiều hoặc phát ra lỗi.
  • Được sử dụng khi cần phát ra lỗi.

• Sự khác nhau giữa Map và Flatmap

  • Map trả về 1 Object thuộc type T
  • Flatmap trả về 1 Observable

• Ví dụ

searchMovie("Doctor Strange")
  .flatMap(json -> {
     try {
      /*Trả về giá trị*/
      return Observable.defer(() -> Observable.just(parse(json)));
    } catch(JSONException e) {
      /*Trả về lỗi nếu có*/
      return Observable.error(e);
    }
  })
  .subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(new Subscriber<List<Movie>>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        showError();
                    }

                    @Override
                    public void onNext(List<Movie> movies) {
                        list.clear();
                        list.addAll(movies);
                        adapter.notifyDataSetChanged();
                    }
  });

 

Bài 5: Operator Map (Nhận và trả về khác kiểu dữ liệu)

• • Đặc điểm khi sử dụng

    • Map sẽ nhận vào 1 giá trị từ observable, dữ liệu trả về không nhất thiết phải cùng type với data nhận vào.
    • Được dùng khi muốn biến đổi dữ liệu nhận từ observable, sau đó đổi lại model mình muốn dùng.

  • Ví dụ

package team.kiti.rxjava2_android.operators.map;


import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.BaseAdapter;

import java.util.List;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import team.kiti.rxjava2_android.BaseActivity;
import team.kiti.rxjava2_android.R;

public class MapExampleActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_map_example);

        getObservable()
                /*Nhận List UserApi chuyển thành List User*/
                .map(new Function<List<UserApi>, List<User>>() {
                    @Override
                    public List<User> apply(List<UserApi> userApis) throws Exception {
                        Log.d(TAG, "apply: " + Thread.currentThread().getName());
                        return User.convertUserApisToUsers(userApis);
                    }
                })
                /*Khởi tạo và chuyển đổi data trên luồng khác*/
                .subscribeOn(Schedulers.io())
                /*Chuyển về luồng 9*/
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getObserver());
    }

    private Observable<List<UserApi>> getObservable() {
        return Observable.create(new ObservableOnSubscribe<List<UserApi>>() {
            @Override
            public void subscribe(ObservableEmitter<List<UserApi>> emitter) throws Exception {
                if (!emitter.isDisposed()) {
                    Log.d(TAG, "subscribe: " + Thread.currentThread().getName());
                    emitter.onNext(UserApi.getListUserApi());
                    emitter.onComplete();
                }
            }
        });
    }

    private Observer<List<User>> getObserver() {
        return new Observer<List<User>>() {

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(List<User> users) {
                Log.d(TAG, "onNext: " + Thread.currentThread().getName());
                Log.d("OKE", "onNext: " + users.size());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
    }
}

D/OKE: subscribe: RxCachedThreadScheduler-1
D/OKE: apply: RxCachedThreadScheduler-1
D/OKE: onNext: main
D/OKE: onNext: 100

Bài 4: Sử dụng subscribeOn, Scheduler và observeOn

• subscribeOn là gi?

  • subscribeOn sẽ nhận vào 1 tham số là Scheduler.
  • Xử lý các công việc trên các Thread được Scheduler cung  cấp.
  • Vị trí gọi của subscribeOn không quan trọng (nằm giữa Observable và Subscriber) bởi vì nó có tác dụng khi hàm subscribe() được gọi.
  • Không nên sử dụng cho Observable.from(), just(), range() vì các hàm này nhận giá trị khi khởi tạo. Thay vào đó dùng Observable.create() hoặc Observable.defer() vì 2 hàm này chỉ khởi tạo Observable khi hàm subscribe() được gọi.
  • Khi bạn gọi nhiều hàm subcribeOn() khác nhau thì chỉ có hàm đầu tiên được sử dụng.

• Scheduler là gì?

  • Scheduler sẽ định nghĩa 1 thread chạy 1 khối lượng công việc, có 1 số lựa chọn.
    1. immediate(): Thực thi trên thread hiện tại.
    2. trampoline(): Sắp xếp 1 hàng chờ công việc trên thread hiện tại thực thi khi công việc hiện tại kết thúc.
    3. newThread(): Tạo ra thread mới cho mỗi công việc.
    4. computation(): Xử lý các công việc tính toán được hỗ trợ bởi 1 thread bool giới hạn số size = cpu.
    5. io(): Xử lý các công việc không mang nặng tính chất tính toán, trên thread bool không giới hạn size. Thực thi các tiến trình bất đồng bộ không ảnh hưởng tới cpu.

• observeOn() là gì?

  • Nhận vào 1 tham số là Scheduler làm cho các Operator hay Subscriber được gọi đằng sau nó chạy trên Thread mới được cung cấp bởi Scheduler đó.
  • Gọi nhiều observeOn() các tham số Scheduler truyền vào sẽ có tác dụng giữa hàm gọi này đến hàm gọi kia. Nói cách khác, observeOn() sẽ có tác dụng ở tất cả các hàm gọi sau nó đến khi nào có 1 hàm observeOn() khác.

• Sự khác nhau giữa subscribeOn và observeOn

  • subscribeOn() có tác dụng với Observable.
  • observeOn() có tác dụng với Operator và Subscriber sau nó.