如何通知多个活动和数据集变更的片段？

Question

Consider an Android app that displays lists of data and lets the user drill down into it. At some point the user makes a change to the data that needs to be reflected in more than one Activity on the back stack. What is the best pattern for achieving this?

Answer 1

First, let's check the cases.

There is a data source in your app. And its updates needs to reflect to multiple UI,

• case 1: some UI maybe just need the whole data source
• case 2: some UI needs to process the data first before showing on the UI

You need to somehow create a single source of truth for all the UI and reflect the changes to them when something happens.

I solved this problem in my project by using MVVM and ViewModel + LiveData from google's new architecture component. Why? Because they are life cycle aware! You can use RxJava to do the same thing.

1. model layer

It's a singleton, and expose the data source as a LiveData A. In the following code, it will be OrderLiveStore.liveData .

    class OrderLiveStore(
        private val orderStore: OrderStore
    ) {
        var liveData: MutableLiveData<List<Order>> = MutableLiveData()

        init {
            liveData.value =  orderStore.items
        }

    }

2. view model layer :

• case 1: You just inject that model to the view model, and expose the LiveData A to the view. Underneath considering the fact of singleton, all views which connect to this view model will get the update, because the view model simply just returns the same property from a singleton variable. I manage the singleton by using dagger .

   class OrdersViewModel @Inject constructor( orderLiveStore: OrderLiveStore ): ViewModel() { // expose to the view directly val orders: LiveData<List<Order>> = orderLiveStore.liveData } 

• case 2: You still inject the model to the view model, but inside, you need to subscribe to it using Transformations.map , and do your processing, and expose the result to the view layer

   class OrderViewModel( orderLiveStore: OrderLiveStore, private val orderId: String ) : ViewModel() { // expose to the view after processing it val order: LiveData<Order> = Transformations.map(orderLiveStore.liveData) { getNeededOrderFromList(it) } private fun getNeededOrderFromList(orderList: List<Order>?): Order? { // This method will be triggered every time orderStore.liveData gets updated } } 

You can see that in case 1, I use dagger to inject because it fits the case. In case 2, I created the view model in view with custom parameter, because the view model needs some extra information to grab the needed pieces from the model layer. In my case, it is a orderId:String

3. view layer

Now it's simple, be it a fragment or an activity, you observe that data source and update your UI,

    orderViewModel.orders.observe(this, Observer {
        // update the ui
    })

or more elegantly, you can bind the LiveData from view model directly to the xml with data binding if you don't need that much pre-processing.

4. What about the CRUD

Well, you just update the model layer DIRECTLY. But the action will be started from one of the 2 layers

• view layer (if it's from a user)
• view model layer (if it's a side-effect).

But even it's from the view , the view will still call methods on view model , and view model will call some methods on model layer or you can simply update it in the view model layer depends on the cases(because you get the single source of truth).

It's kind of like Redux pattern - a nearly unidirectional data flow, where every change will happen at model layer and reflect back to view model layer, then bubble up to view layer. It's easy to reason about your data flow.

5. And the result will be what you want.

Because everything is now connected to a single source of truth(a shared model layer), but, in a decoupled manner. Every layer does its own job.

6. One more tip

In order to get Transformations.map to work, you need to observe the result in the view, otherwise, that subscription from Transformations.map will not work at all.

Answer 2

You can put your shared data in a Service , then in your fragment/activity's onResume methods you can get updated data from there.

To update your current fragment/activity you can fire an event when you update data in the Service, registering your fragment/activity to catch it and consequently update your showed data. You could use OttoBus to achieve this goal