🔎 LiveData란

관찰 가능한 (Observable) 데이터 홀더 클래스로, 다른 Observable 데이터와 달리 액티비티, 프래그먼트 또는 서비스와 같은 다른 앱 컴포넌트의 라이프사이클을 고려함.
즉, 활성(active) 라이프사이클 상태에 있는 앱 컴포넌트 관찰자(Observer)만 업데이트한다는 것을 보장함.

• LiveData는 Observer 클래스로 표현되는 옵저버만 고려하며, 해당 라이프 사이클이 STARTED 또는 RESUMED 상태에 있는 경우를 활성 상태로 간주하여 업데이트에 대한 알림을 제공함.

• LifecycleOwner인터페이스를 구현하는 개체와 관련된 옵저버를 등록할 수 있음.
  해당 라이프사이클 객체의 상태가 DESTROYED로 변경되면 옵저버를 제거할 수 있음.
  -> 액티비티, 프래그먼트에 유용. (라이프사이클이 소멸되면 즉시 구독 해지 가능하기 때문)

---

📖 LiveData 사용의 장점

1. UI가 데이터 상태와 일치함을 보장.
LiveData는 데이터가 변경될 때 Observer 개체에 알리고, 따라서 데이터가 변경될 때마다 UI를 업데이트할 필요가 없음.

2. 메모리 누수 방지
옵저버는 라이프사이클 객체에 바인딩되며 연결된 라이프사이클이 소멸될 때 스스로 정리함.

3. 중지된 액티비티로 인한 충돌이 없음.
옵저버의 라이프사이클이 비활성 상태인 경우 (예: 백스택에 있는 액티비티) LiveData 이벤트를 수신하지 않음.

4. 수동 라이프사이클 처리가 필요 없음.
UI 구성 요소는 관련된 데이터만 관찰하며 관찰을 중지하거나 재개하지 않음. LiveData는 관찰 도중에 관련 라이프사이클 상태 변경을 자동으로 관리함.

5. 항상 최신 데이터 사용.
라이프사이클이 비활성인 경우 다시 활성 상태가 되면 최신 데이터를 수신함.
(백그라운드에 있는 액티비티가 다시 화면으로 돌아오면 최신 데이터를 즉시 받음.)

6. 올바른 구성 변경
액티비티나 프래그먼트가 디바이스 회전과 같은 구성 변경으로 다시 생성되면 즉시 사용 가능한 최신 데이터를 수신함.

7. 리소스 공유
싱글톤 패턴을 사용하여 LiveData 객체를 시스템 서비스에 한번 연결하고, 해당 리소스가 필요한 옵저버는 LiveData객체를 감시할 수 있음.

---

📖 LiveData 객체로 작업하기

1. 특정 유형의 데이터를 보유할 LiveData 인스턴스를 생성.
   일반적으로 ViewModel 클래스 내에서 수행됨.

2. LiveData 객체의 보유 데이터가 변경될 때 작업을 제어하는 onChanged() 메서드를 정의하는 Observer 객체를 생성함. 일반적으로는 액티비티 또는 프래그먼트와 같은 UI 컨트롤러에서 생성함.

3. observe() 메서드를 사용하여 Observer객체를 LiveData 객체에 등록.
   observer() 메서드는 LifecycleOwner 객체를 사용함.
   Observer 객체는 일반적으로 액티비티나 프래그먼트와 같은 UI 컨트롤러에서 LiveData 객체에 등록함.

LiveData 객체에 저장된 값이 업데이트 되면, 연결된 LifecycleOwner가 활성 상태에 있는 한 모든 등록된 관찰자를 트리거함.

LiveData는 UI 컨트롤러 옵저버가 업데이트에 구독할 수 있도록 허용함.
LiveData 객체가 보유하는 데이터가 변경되면 UI가 자동으로 응답하여 업데이트됨.

📝 참고
observeForever(Observer) 메서드를 사용하여 연결된 LifecycleOwner 객체 없이 옵저버를 등록할 수 있음
-> 이 경우 옵저버는 항상 활성 상태로 간주되므로 항상 수정 사항에 대해 알림을 받음.
이런 옵저버는 removeObserver(Observer) 메서드를 호출하여 제거할 수 있음.

📚 LiveData 객체 생성하기

LiveData는 List와 같은 Collections를 구현하는 개체를 포함하여 모든 데이터와 함께 사용할 수 있는 래퍼. LiveData 객체는 일반적으로 ViewModel 객체 내에 저장되며 getter메서드를 통해 액세스됨.

LiveData 객체 내의 초기 데이터는 설정되지 않음.

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

    // Rest of the ViewModel...
}

UI 업데이트를 수행하는 LiveData 객체를 액티비티나 프래그먼트 대신 ViewModel 객체에 저장해야하는 이유

• 복잡한 코드의 액티비티와 프래그먼트를 피하기 위해. (To avoid bloated activiteds and fragments.) UI 컨트롤러는 데이터를 표시하는 역할을 하지만 데이터 상태를 보유하지 않음.
  
  
• LiveData 인스턴스를 특정 액티비티나 프래그먼트 인스턴스와 분리시키고 LiveData 객체가 구성 변경으로부터 살아남도록 하기 위해.

📚 LiveData 객체 관찰하기

onCreate() 메서드가 LiveData 객체를 관찰하기에 적절한 이유

• 시스템이 액티비티나 프래그먼트의 onResume()에서 중복 호출을 하지 않는 것을 보장하기 위해.

• 액티비티 또는 프래그먼트가 활성 상태가 되자마자 표시할 데이터가 있는지 확인하는 것을 보장하기 위해. 앱 컴포넌트가 STARTED 상태가 되면 관찰 중인 LiveData 객체로부터 가장 최신 값을 수신함.

LiveData는 데이터가 변경될 때만 업데이트를 전달하고 활성화된 옵저버에게만 전송.

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Other code to setup the activity...

        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            nameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.currentName.observe(this, nameObserver)
    }
}

📚 LiveData 객체 업데이트

LiveData는 저장된 데이터를 업데이트하기 위한 public 메서드가 없음.
MutableLiveData 클래스는 setValue(T) 및 postValue(T) 메서드를 공개하며
LiveData 객체에 저장된 값을 수정해야 할 경우 이 메서드들을 사용해야 함.

MutableLiveData는 ViewModel에서 사용되고, ViewModel은 옵저버에게 불변의 LiveData 객체를 노출함.

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

📚 Room으로 LiveData 사용

Room 라이브러리는 LiveData 객체를 반환하는 observable 쿼리를 지원함.
Observable 쿼리는 DAO의 일부로 작성됨.

Room은 데이터베이스가 업데이트될 때 LiveData 객체를 업데이트하기 위해 필요한 코드를 생성.

생성된 코드는 필요한 경우 백그라운드 스레드에서 쿼리를 비동기적으로 실행.

• UI에 표시된 데이터와 데이터베이스에 저장된 데이터를 동기화하는데 유용.

---

📖 앱 아키텍처에서의 LiveData

• LiveData와 UI 컨트롤러
  LiveData는 엔티티(액티비티 및 프래그먼트)의 라이프사이클을 고려하며, 라이프사이클 소유자와 ViewModel 객체와 같은 수명이 다른 객체 간의 통신에 사용함.

ViewModel의 주요 역할은 UI 관련 데이터를 로드하고 관리하는 것이므로 LiveData 객체를 보유하기 좋음. ViewModel에서 LiveData 객체를 생성하고 UI 레이어에 노출시킴.

액티비티와 프래그먼트는 LiveData 인스턴스를 보유해서는 안됨.
-> UI 컨트롤러의 역할은 데이터를 표시하는 것이 아닌 상태를 보유하는 것.
-> 액티비티와 프래그먼트가 데이터를 보유하지 않는 것이 유닛 테스트를 작성하기 더 쉬움.

• LiveData와 데이터 레이어 클래스
  LiveData는 데이터의 비동기 스트림을 처리하도록 설계되지 않았으므로 Repository에서 LiveData를 보유할 경우 메인 스레드가 차단될 수 있음.

//메인 스레드가 차단될 수 있는 코드
class UserRepository {

    // DON'T DO THIS! LiveData objects should not live in the repository.
    fun getUsers(): LiveData<List<User>> {
        ...
    }

    fun getNewPremiumUsers(): LiveData<List<User>> {
        return getUsers().map { users ->
            // This is an expensive call being made on the main thread and may
            // cause noticeable jank in the UI!
            users
                .filter { user ->
                  user.isPremium
                }
          .filter { user ->
              val lastSyncedTime = dao.getLastSyncedTime()
              user.timeCreated > lastSyncedTime
                }
    }
}

• 앱의 다른 레이어에서 데이터 스트림을 사용해야할 경우 Kotlin Flows를 사용하고 ViewModel에서
  asLiveData()를 사용하여 LiveData로 변환하는 것을 고려해야 함.

• Java로 빌드된 코드베이스는 콜백 혹은 RxJava와 결합하여 Executors를 사용하는 것을 고려해야 함.

---

📖 LiveData 확장

//주식 가격 업데이트 

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }
}

1. onActive() 메서드는 LiveData 객체에 활성 옵저버가 있을 경우 호출됨.
   이 메서드에서 주식 가격 업데이트를 관찰하기 시작해야함.

2. onInactive() 메서드는 LiveData 객체에 활성 옵저버가 없는 경우 호출됨.
   활성 옵저버가 없기 때문에 StockManager 서비스와 연결을 유지할 이유가 없음.

3. setValue(T) 메서드는 LiveData 인스턴스의 값을 업데이트하고 변경 사항을 활성화 된 옵저버에게 알림.

//이렇게도 사용 가능
public class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val myPriceListener: LiveData<BigDecimal> = ...
        myPriceListener.observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })
    }
}

• 싱글톤으로 구현

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager: StockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }

    companion object {
        private lateinit var sInstance: StockLiveData

        @MainThread
        fun get(symbol: String): StockLiveData {
            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
            return sInstance
        }
    }
}


class MyFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        StockLiveData.get(symbol).observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })

    }

여러 프래그먼트와 액티비티가 StockLiveData 인스턴스 관찰 가능. (프래그먼트나 액티비티가 보이고 있고 -visible, 활성인 경우에만 연결.)

---

📖 LiveData 변환

LiveData 객체에 저장된 값을 옵저버에게 전달하기 전에 해당 값을 변경하거나, 다른 LiveData 인스턴스를 반환해야할 수 있으므로 Transformation 클래스가 제공됨.

• Transformations.map()
  LiveData 객체에 저장된 값에 변환 함수를 적용하고 결과를 downstream으로 보냄.

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = userLiveData.map {
    user -> "${user.name} ${user.lastName}"
}

• Transformations.switchMap()
map()과 유사하게 LiveData 객체에 저장된 값에 함수를 적용하고 결과를 downstream 으로 전파.

private fun getUser(id: String): LiveData<User> {
  ...
}
val userId: LiveData<String> = ...
val user = userId.switchMap { id -> getUser(id) }

+) 231209 내용 추가

LiveData<Y> switchMap (LiveData<X> trigger, 
                Function<X, LiveData<Y>> func)

trigger 변경사항이 func에 적용됨. func이 null을 반환하는 경우 LiveData는 backed되지 않음.
func은 메인 스레드에서 실행됨.

 MutableLiveData userIdLiveData = ...;
 LiveData userLiveData = Transformations.switchMap(userIdLiveData, id ->
     repository.getUserById(id));

 void setUserId(String userId) {
      this.userIdLiveData.setValue(userId);
 }
 

위 코드에서 repository가 User(1, "Jane"), User(2, "John") 이라는 값을 가지고 있다고 가정했을 때, userIdLiveData에 1이 설정되면 switchMap은 getUserById(1)을 호출하여 LiveData를 반환함.
따라서 userLiveData는 User(1, "Jane")을 방출함.

userId=2로 setUserId 메소드가 호출되면 userIdLiveData값이 변경되고 저장소에서 ID가 2인 user를 가져오기 위한 요청이 자동으로 트리거됨.
userLiveData는 User(2, "John")을 방출함.
repository.getUserById(1)에서 반환된 LiveData는 소스에서 제거됨.

예시)
주소를 입력받아 해당 주소의 우편번호를 반환하는 UI 요소가 있는 경우

1. 첫번째 코드
   UI에서 getPostalCode()를 호출할 떄마다 이전 LiveData 객체에서 등록 해제하고 새 인스턴스에 등록해야 함.

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {

    private fun getPostalCode(address: String): LiveData<String> {
        // DON'T DO THIS
        return repository.getPostCode(address)
    }
}

2. 개선된 코드
   postalCode 필드와 관련된 활성 옵저버가 있는 한, addressInput이 변경될 때마다 필드의 값이 다시 계산되고 검색됨.
   따라서 ViewModel 객체는 쉽게 LiveData에 대한 참조를 얻고 변환 규칙을 정의할 수 있음.

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
    private val addressInput = MutableLiveData<String>()
    val postalCode: LiveData<String> = addressInput.switchMap {
            address -> repository.getPostCode(address) }


    private fun setInput(address: String) {
        addressInput.value = address
    }
}

---

📖 여러 개의 LiveData 병합

• MediatorLiveData

여러 LiveData 원본을 병합할 수 있도록 해주는 LiveData의 하위 클래스.
MediatorLiveData 객체의 관찰자는 LiveData 원본 객체 중 하나라도 변경될 때마다 트리거됨.

예시)

UI에 있는 LiveData 객체가 로컬 데이터베이스 또는 네트워크에서 업데이트될 수 있는 경우
데이터베이스에 저장된 데이터와 관련된 LiveData 객체.
네트워크에서 액세스된 데이터와 관련된 LiveData 객체.
를 MediatorLiveData 객체에 추가할 수 있음.