当我回到片段时，立即调用观察者答案

【问题标题】：When I go back to a Fragment the observer is immediately called当我回到片段时，立即调用观察者
【发布时间】：2020-05-07 12:01:51
【问题描述】：

我有一个观察者，当它被称为更改片段时。

问题是当我返回时立即调用观察者并且我的应用程序崩溃了

java.lang.IllegalArgumentException：导航目的地 com.superapps.ricardo.tablepro:id/action_searchFragment_to_yourGameList2 此 NavController 未知。

我不明白为什么要调用它。

这是唯一改变列表的方法

override fun onSuccess(gamePair: Pair<Int, List<BggGame>>) {
        CoroutineScope(Main).launch{
            //goToList(gamePair.second, binding.input.text.toString())
            viewModel.setGameList(gamePair.second)
        }
    }

这是视图模型创建和更改片段代码

override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        viewModel = ViewModelProviders.of(this).get(SearchViewModel::class.java)
        viewModel.gameList.observe(viewLifecycleOwner, Observer {
            goToList(it, binding.input.text.toString())
        })
    }


    private fun goToList(games: List<BggGame>, user: String) {
        val action = SearchFragmentDirections.actionSearchFragmentToYourGameList2(user)
        val gameList = GameList()
        gameList.gameList = games
        action.gameList = gameList

        try {
            Navigation.findNavController(view!!).navigate(action)
            viewModel.gameList.removeObservers(viewLifecycleOwner)
        } catch (e: Exception){
            Log.e("a0,","a..", e)
        }
        progressDialog.dismiss()

    }

【问题讨论】：

请分享您的 viewModel 代码！！

标签： android kotlin observers

【解决方案1】：

LiveData 保留最后设置的值。在LivaData 上调用observe() 时，如果LiveData 有值，则会立即使用先前设置的值调用观察者。

如果您想将LiveData 用于像您的用例这样的“事件”，您的实时数据应该公开一个只能使用一次的Event 对象。

这是一个很好的implementation 的例子，它是这样一个Event 类。

来自文章：

open class Event<out T>(private val content: T) {

    var hasBeenHandled = false
        private set // Allow external read but not write

    /**
     * Returns the content and prevents its use again.
     */
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    /**
     * Returns the content, even if it's already been handled.
     */
    fun peekContent(): T = content
}

在 ViewModel 中的使用：

val gameList = MutableLiveData<Event<List<BggGame>>()
fun setGameList(gameList: List<BggGame>) {
    gameList.value = Event(gameList)
}

视图中的用法：

viewModel.gameList.observe(this, Observer {
    it.getContentIfNotHandled()?.let { // Only proceed if the event has never been handled
        goToList(it, binding.input.text.toString())
    }
})

【讨论】：

你忘记了例子 xD
确实，我更新了帖子，提供了一个很好地解释问题的链接。

【解决方案2】：

在您的viewModel 中使用SingleLiveEvent 而不是MutableLiveData 或LiveData。

这是SingleLiveEvent类，你可以在util包中使用它：

import android.util.Log;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import java.util.concurrent.atomic.AtomicBoolean;

public class SingleLiveEvent<T> extends MutableLiveData<T> {

    private static final String TAG = "SingleLiveEvent";

    private final AtomicBoolean mPending = new AtomicBoolean(false);

    @Override
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {

        if (hasActiveObservers()) {
            Log.w(TAG, "Multiple observers registered but only one will be notified of changes.");
        }

        // Observe the internal MutableLiveData
        super.observe(owner, new Observer<T>() {
            @Override
            public void onChanged(@Nullable T t) {
                if (mPending.compareAndSet(true, false)) {
                    observer.onChanged(t);
                }
            }
        });
    }


    @MainThread
    public void setValue(@Nullable T t) {
        mPending.set(true);
        super.setValue(t);
    }
}

【讨论】：