Android에서 RxJava를 사용하는시기와 Android Architectural Components에서 LiveData를 사용하는시기는 언제입니까?

Android에서 RxJava를 사용하는시기와 Android Architectural Components에서 LiveData를 사용하는시기는 언제입니까?

---

Android에서 RxJava를 사용하고 Android Architectural Components에서 LiveData를 사용해야 할 이유를 얻지 못했습니다. 두 가지의 유스 케이스와 차이점을 샘플 예제와 함께 코드 형식으로 설명하면 두 가지의 차이점을 설명하는 것이 정말 도움이 될 것입니다.

---

Android LiveData는 활성 / 비활성 전환이 추가 된 원래 옵저버 패턴의 변형입니다. 따라서 범위가 매우 제한적입니다.

Android LiveData에 설명 된 예제를 사용하여 위치 데이터를 모니터링하고 애플리케이션 상태를 기반으로 등록 및 등록 취소하기위한 클래스가 작성됩니다.

RxJava는 훨씬 일반화 된 연산자를 제공합니다. 이 관측 가능 위치 데이터를 제공한다고 가정 해 봅시다.

Observable<LocationData> locationObservable;

Observable.create()콜백 작업을 매핑 하기 위해 옵저버 블의 구현을 구축 할 수 있습니다 . 옵저버 블이 구독되면 콜백이 등록되고 구독이 취소되면 콜백이 등록되지 않습니다. 구현은 예제에 제공된 코드와 매우 유사합니다.

또한 응용 프로그램이 활성화 될 때 true를 방출하는 Observable이 있다고 가정합니다.

Observable<Boolean> isActive;

그런 다음 다음을 통해 LiveData의 모든 기능을 제공 할 수 있습니다.

Observable<LocationData> liveLocation =
  isActive
    .switchMap( active -> active ? locationObservable : Observable.never() );

switchMap()응용 프로그램이 활성화되어 있지 않으면 운영자 역시 현재의 스트림으로 위치하거나 아무것도 제공한다. 당신은 일단 liveLocation관찰을, 거기에 당신이 RxJava 연산자를 사용하여 함께 할 수있는 많은 것들을. 내가 가장 좋아하는 예는 다음과 같습니다.

liveLocation.distinctUntilChanged()
  .filter( location -> isLocationInAreaOfInterest( location ) )
  .subscribe( location -> doSomethingWithNewLocation( location ) );

위치가 변경된 경우에만 작업을 수행하며 위치가 흥미 롭습니다. 시간 연산자를 결합하여 속도를 결정하는 유사한 작업을 만들 수 있습니다. 더 중요한 것은 RxJava 연산자를 사용하여 메인 스레드에서 작업이 발생하는지 또는 백그라운드 스레드에서 발생하는지 또는 다중 스레드에서 발생하는지에 대한 세부 제어를 제공 할 수 있습니다.

RxJava의 핵심은 라이브러리에서 제공되는 작업 또는 사용자가 제공 한 사용자 지정 작업을 사용하여 제어 및 타이밍을 단일 유니버스로 결합한다는 것입니다.

LiveData는 해당 유니버스의 하나의 작은 부분 만 처리합니다 liveLocation.

---

원래 질문과 관련하여 RxJava와 LiveData는 서로를 잘 보완합니다.

LiveDataAndroid 라이프 사이클 및과의 긴밀한 통합으로 ViewModel 레이어에서 빛을 발합니다 ViewModel. RxJava@Bob Dalgleish에서 언급 한대로 더 많은 변환 기능을 제공합니다.

현재 우리는 RxJava데이터 소스 및 리포지토리 레이어에서 사용하고 있으며 ViewModels에서 데이터를 활동 / 조각에 노출하기 전에 으로 변환 LiveData하여 사용 LiveDataReactiveStreams합니다.이 접근법에 매우 만족합니다.

---

LiveData와 RxJava에는 많은 차이점이 있습니다.

1. LiveData는 아니다 STREAM RxJava 모든 (문자 그대로 모든)은 인에있는 동안 STREAM .
2. LiveData는 관찰 가능한 데이터 홀더 클래스입니다. 일반 관찰 가능과 달리 LiveData는 수명주기를 인식하므로 활동, 프래그먼트 또는 서비스와 같은 다른 앱 구성 요소의 수명주기를 존중합니다. 이 인식은 LiveData가 활성 수명주기 상태 인 앱 구성 요소 관찰자 만 업데이트하도록합니다.
3. LiveData는 동기식 이므로 RxJava와 마찬가지로 LiveData 만 사용하여 코드 청크 (네트워크 호출, 데이터베이스 조작 등)를 비동기 적으로 실행할 수 없습니다.
4. 이 듀오를 최대한 활용하기 위해 할 수있는 최선의 방법은 비즈니스 로직 (네트워크 호출, 데이터 조작 등, 리포지토리 내외에서 발생하는 모든 작업)에 RxJava를 사용하고 프레젠테이션 계층에 LiveData를 사용하는 것입니다. 이를 통해 비즈니스 로직 및 수명주기 인식 작업을위한 변환 및 스트림 기능을 사용할 수 있습니다.
5. LiveData와 RxJava 는 함께 사용될 경우 서로 보완 합니다. 내 말은 RxJava로 모든 것을하고 UI를 업데이트하려고 할 때 Observable을 LiveData로 변경하려면 아래 주어진 코드와 같은 것을하십시오. 따라서 View (UI)는 LiveData가 변경 불가능한 MutableLiveData이거나 MutableLiveData가 변경 가능한 LiveData 인 ViewModel의 LiveData를 관찰합니다.
6. 여기서 질문은 왜 LiveData를 처음부터 사용해야합니까? 아래 코드에서 볼 수 있듯이 RxJava에서 MutableLiveData (또는 LiveData) 로의 응답을 저장하고 LiveData는 수명주기를 인식하므로 데이터는 수명주기를 인식합니다. 이제 데이터 자체가 UI 업데이트시기와시기를 알고있을 때의 가능성을 상상해보십시오.
7. LiveData에는 기록이 없습니다 (현재 상태 만). 따라서 채팅 응용 프로그램에 LiveData를 사용해서는 안됩니다.
8. RxJava와 함께 LiveData를 사용하면 MediatorLiveData , SwitchMap 등과 같은 것이 필요하지 않습니다 . 스트림 제어 도구이며 RxJava가 여러 번 더 좋습니다.
9. 데이터 홀더로 LiveData를 참조하십시오. 또한 LiveData는 수명주기 인식 소비자라고 말할 수 있습니다.

---

    public class RegistrationViewModel extends ViewModel {
        Disposable disposable;

        private RegistrationRepo registrationRepo;
        private MutableLiveData<RegistrationResponse> modelMutableLiveData =
                new MutableLiveData<>();

        public RegistrationViewModel() {
        }

        public RegistrationViewModel(RegistrationRepo registrationRepo) {
            this.registrationRepo = registrationRepo;
        }

        public void init(RegistrationModel registrationModel) {
            disposable = registrationRepo.loginForUser(registrationModel)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<Response<RegistrationResponse>>() {
                        @Override
                        public void accept(Response<RegistrationResponse>
                                                   registrationModelResponse) throws Exception {

                            modelMutableLiveData.setValue(registrationModelResponse.body());
                        }
                    });
        }

        public LiveData<RegistrationResponse> getModelLiveData() {
            return modelMutableLiveData;
        }

       @Override
       protected void onCleared() {
                super.onCleared();
            disposable.dispose();
         }
    }

---

In fact, LiveData is not an essentially different tool to RxJava , so why was it introduced as an architecture component when RxJava could have easily managed the lifecycle by storing all the subscriptions to observables in a CompositeDispoable object and then disposing them in onDestroy() of the Activity or onDestroyView() of the Fragment using only one line of code?

I have answered to this question fully by building a movie search app once using RxJava and then using LiveData here.

But in short, yes, it could, but that would need first overriding the relevant lifecycle methods besides having the basic lifecycle knowledge. This still might not make sense for some, but the fact is that according to one of the Jetpack sessions in Google I/O 2018 many developers find lifecycle management complex. The crash errors arising from not handling lifecycle dependence might be another sign that some developers, even if knowledgable of lifecycle, forget to take care of that in every Activity / Fragment they use in their app. In large apps this could become an issue, notwithstanding the negative effect it could have on productivity.

The bottom line is that by introducing LiveData , larger number of developers are expected to adopt MVVM without even having to understand the lifecycle management, memory leak and crash. Even though I have no doubt that LiveData is not comparable with RxJava in terms of capabilities and the power it gives to developers, reactive programming and RxJava is a hard-to-understand concept and tool for many. On the other side, I do not think LiveData is meant to be a replacement for RxJava–it simply cannot–but a very simple tool for handling a controversial widespread issue experienced by many developers.

** UPDATE ** I have added a new article here where I have explained how misusing LiveData can lead to unexpected results. RxJava can come to rescue in these situations

---

---

As you may know in the reactive ecosystem we have an Observable that emits data and an Observer that subscribes( get notified) of this Observable emission, nothing strange is how works the so called Observer Pattern. An Observable "shouts"something, the Observer get notified that Observable shout something in a given moment.

Think to LiveData as an Observable that allows you to manage the Observers that are in an active state. In other terms LiveData is a simple Observable but also takes care of the life cycle.

But let's see the two code cases you request:

A) Live Data

B) RXJava

A)This is a basic implementation of LiveData

1) you usually instantiate LiveData in the ViewModel to maintain orientation change (you can have LiveData that is read only, or MutableLiveData that is writable, so you usually expose outside from the class LiveData)

2) in the OnCreate method of the Main Activity(not the ViewModel) you "subscribe" an Observer object (usually an a onChanged method)

3) you launch the method observe to establish the link

First the ViewModel (owns the business logic)

class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

And this is the MainActivity( as dumb as possible)

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)

        ViewModelProvider.observe(this, Observer {//Points 2 and 3
            //what you want to observe
        })


        }
    }
}

B)This is the basic implementation of RXJava

1) you declare an Observable

2) you declare an Observer

3) you subscribe the Observable with the Observer

Observable.just(1, 2, 3, 4, 5, 6) // Point 1

   .subscribe(new Subscriber() {    //Points 2 & 3
       @Override
       public void onCompleted() {
           System.out.println("Complete!");
       }

       @Override
       public void onError(Throwable e) {
       }

       @Override
       public void onNext(Double value) {
           System.out.println("onNext: " + value);
       }
    });

In particular LiveData is used with Lifecycle and often with ViewModel(as we have seen) architecture components. In fact when LiveData is combined with a ViewModel allows you to keep updated in real time every change in the Observer, so that the events are managed in real time where is needed. To use LiveData is strongly recommended to know the concept of lifecycle and the relative objects LifeCycleOwner/LifeCycle, also I would suggest you to have a look at Transformations, if you want to implement LiveData in real life scenarios. Here you can find some use cases from the great commonsware.

To wrap up basically LiveData is a simplified RXJava, an elegant way to observe changes across multiple components without creating explicit so called dependency rules between the components, so that you can test much easier the code and make it much more readable. RXJava, allows you to do the things of LiveData and much more. Because of the extended functionalities of RXJava, you can both use LiveData for simple cases or exploit all the power of RXJava keep using Android Architecture components as the ViewModel, of course this means that RXJava can be far more complex, just think has hundreds of operators instead of SwitchMap and Map of LiveData(at the moment).

RXJava version 2 is a library that revolutionized the Object Oriented paradigm, adding a so called functional way to manage the flow of the program.

---

LiveData is a subset of the android architecture components which is developed by the android team.

With the live data and other architecture components, memory leaks and other similar issues are handled by architecture components. Since it is developed by android team, it is the best for android. They also provide updates that handle new versions of Android.

If you only want to use in Android app development, go for the Android architecture components. Otherwise, if you want to use other Java app, like web app, desktop apps, etc., use RxJava

---

LiveData as a data holder thing and nothing else. We can also say LiveData is Lifecycle aware consumer. LiveData is strongly recommended to know the concept of lifecycle and the relative objects LifeCycleOwner/LifeCycle, you get transformation and stream capabilities for your business logic and lifecycle aware operation for your UI.

Rx is powerful tool that enables to solve of problem in an elegant declarative style. It handles business side options or Service Api operations

참고URL : https://stackoverflow.com/questions/46312937/when-to-use-rxjava-in-android-and-when-to-use-livedata-from-android-architectura