android - MVVM android中的路由(最佳实践)

Question

我使用MVVM模式。我想知道其他程序员如何在屏幕之间进行路由。
可以这样完成:

class MyViewModel : ViewModel() {
    val routeState = MutableLiveData<String>()

    init {
        //more fun 
        //...
        //...
        routeState.value = "Home"
    }
}

class MyActivity : Activity() {
    private lateinit var viewModel: MyViewModel
    
    onCreate() {
        //viewModel init 
        
        viewModel.routeState.observe(viewLifecycleOwner, Observer {
            when(it) {
                "Home" -> {
                    toHome()
                    //finish()
                }
            }
        })
    }
}

我知道这种方法不好。所以我想问你如何做？

Answer 1

如果要明确路由，则需要执行一些步骤:
1.)永远不会在任务堆栈上同时拥有2个Activity，更希望为该应用拥有1个Activity，并在该Activity内部管理路由。
2.)您需要考虑应用何时进入后台，被Android杀死并恢复。即用即用的碎片是根据其当前的“添加”状态重新创建的，但是除非从private val currentRoute: MutableLiveData<String>进行初始化，否则您的savedStateHandle.getLiveData("route")将在进程死亡时丢失。
3.)您需要考虑到屏幕具有参数，有时有时比仅字符串复杂，除非您开始将这些“路由”序列化为JSON对象，或者使用Parcelable类代替String。
4.)您需要考虑通常在onStop之后开始导航通常是无效的，因此您想忽略命令(如Jetpack Navigation那样)，或者将它们排队直到onResume之后。
5.)您需要考虑到导航可以是异步的(不是立即的)，尽管当您使用Fragments时，您通常不必为此担心。例如，Jetpack Navigation并不真正在乎这一点(DynamicNavHostFragment中除外)。
6.)您需要考虑的是，如果导航是异步的，则在进行导航时可以获取导航操作。您可能要对此加以防范，或者将其排队。或者在前进时将它们排入队列，但在返回后将它们忽略(以消除某些无效状态)。
如果将所有这6个因素都考虑在内，则最终得到我编写的库:https://github.com/Zhuinden/simple-stack
现在您的导航非常简单

class MyViewModel(private val backstack: Backstack) : CustomViewModel() {
    fun toOtherScreen() {
        backstack.goTo(OtherScreen())
    }
}

class MyActivity: AppCompatActivity(), SimpleStateChanger.NavigationHandler {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.my_activity)

        // ...

        Navigator.configure()
                 .setStateChanger(SimpleStateChanger(this))
                 .install(this, container, History.of(HomeScreen())
    }

     override fun onNavigationEvent(stateChange: StateChange) {
         val screen = stateChange.topNewKey<Any>()
         when {
             screen is HomeScreen -> {
                ...
             }
             screen is OtherScreen -> {
                ...
             }
         }
     }
}

@Parcelize object HomeScreen: Parcelable // i prefer data classes for a stable `toString()`

@Parcelize object OtherScreen: Parcelable // i prefer data classes for a stable `toString()`

几乎可以做到这一点，除了您可能要使用Fragment之外，请查阅自述文件以了解如何使用 DefaultFragmentStateChanger而不是内置的东西。

好的，所以假设您出于某种原因没有买进我的图书馆。如今，人们通常使用Jetpack导航。
在这种情况下，您希望将一个 Activity 范围的ViewModel传递到您的ViewModel中，其中该 Activity 范围的ViewModel包含一个 LiveData<Event<NavigationCommand>>(假设您没有购买我的其他lib EventEmitter，而是使用事件包装器)，即为了观察从ViewModel触发的导航而被Activity观察到，但是导航状态仍由Jetpack Navigation的NavController管理。

class MyViewModel(private val navigationDispatcher: NavigationDispatcher) : ViewModel() {
    fun toOtherScreen() {
        navigationDispatcher.emit { navController ->
            navController.navigate(HomeDirections.toOtherScreen())
        }
    }
}

class MyActivity : Activity() {
    private val navigationDispatcher by viewModels<NavigationDispatcher>()

    private val viewModel by viewModels {
        object: ViewModelProvider.Factory {
            override fun <T: ViewModel?> create(clazz: Class<T>): T = MyViewModel(navigationDispatcher)
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.my_activity)            

        navigationDispatcher.navigationCommands.observeEvent(this) { command ->
            command.invoke(Navigation.findNavController(this, R.id.nav_host))
        }
    }
}

typealias NavigationCommand = (NavController) -> Unit

class NavigationDispatcher: ViewModel() {
    private val navigationEmitter: MutableLiveData<Event<NavigationCommand>> = MutableLiveData()
    val navigationCommands: LiveData<Event<NavigationCommand>> = navigationEmitter

    fun emit(navigationCommand: NavigationCommand) {
        navigationEmitter.value = Event(navigationCommand)
    }
}

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

    var hasBeenHandled = false
        private set

    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    fun peekContent(): T = content
}

class EventObserver<T>(private val onEventUnhandledContent : (T) -> Unit): Observer<Event<T>> {
    override fun onChanged(event: Event<T>?) {
        event?.getContentIfNotHandled()?.let {
            onEventUnhandledContent(it)
        }
    }
}

inline fun <T> LiveData<Event<T>>.observeEvent(
    lifecycleOwner: LifecycleOwner,
    crossinline observer: (T) -> Unit
): Observer<Event<T>> = EventObserver<T> { t -> observer(t) }.also {
    this.observe(lifecycleOwner, it)
}