你是否厌倦了这种写法？
if (UserManager.isLogin()) {
do something.....
.....
} else {
do something......
.....
}
亦或是这种写法？
if (!UserManager.isLogin()) {
callLogin{
if(success){
do something......
....
}
}
}
那么今天，我将给你一个优雅的登录实现方案~
说到登录，我们不得不聊到一个设计模式——状态模式，顾名思义，他是专门用来处理不同状态的不同动作的设计模式。
他的类图是这样子的。
state_pattern_uml_diagram.png
简单理解，就是借助通过接口的实现类，实现不同状态下的同一个动作，然后借助context类统一处理。非常好理解，这里不多说，不懂的可以看传送门
那么我们今天就借助状态模式来实现一个登录方案吧~
老规矩，先看效果~
处理登录、匿名状态下的不同动作，如点击某个按钮，弹出窗口不一致时，我们可以分别在Success,guest中处理登录或者游客不同的跳转等。
//模块化代理类，不懂的请看本系列模块化讲解部分
LoginProxy.action(this, false) {
it.onSuccess {
这里处理登录状态下的某个动作，如不同的ui，点击按钮不同的反馈等
//do something
}
it.onGuest {
这里处理注销状态下的某个动作，如不同的ui，点击按钮不同的反馈等
}
}
某个动作需要登录，然后继续执行操作等，例如点击评论按钮->弹出登录页面->登录成功后弹出评论弹框等
LoginProxy.action(this) {
it.onSuccess {
弹出评论弹框
}
it.onCancel {
用户取消登录，如不使用，可以忽略
}
}
接下来我们一步一步实现这个方案吧~
首先是我们聊到的状态模式，这里直接给出代码参考
首先是接口
interface ILoginState {
/**
* @param context
* @param requestLogin 当游客状态时，执行某个动作是否需要呼起登录弹框
* @param loginParams 登录参数，传入loginActivity
* @param block 执行结果回调
*/
fun action(
context: LifecycleOwner,
requestLogin: Boolean,
loginParams: MutableMap<LoginParams, Any>,
block: (result: LoginResult) -> Unit
)
}
然后我们给出两个实现类，即登录状态和游客状态
class LoginState : ILoginState {
override fun action(
context: LifecycleOwner,
requestLogin: Boolean,
loginParams: MutableMap<LoginParams, Any>,
block: (result: LoginResult) -> Unit
) {
block(LoginResult.Success())
}
}
class GuestState : ILoginState {
override fun action(
context: LifecycleOwner,
requestLogin: Boolean,
loginParams: MutableMap<LoginParams, Any>,
block: (result: LoginResult) -> Unit
) {
if (requestLogin) {
context.requestLogin(loginParams, block)
} else {
block(LoginResult.Guest())
}
}
}
可以看到，登录状态我们直接执行block的success方法，而游客状态则看传入的requestLogin参数来判断执行登录操作还是回调guest运行操作。
然后是context管理类，统一我们的整合条件
object LoginContext {
private var mLoginState: ILoginState = GuestState()
val loginFlow = MutableStateFlow<UserModel?>(null)
fun init() {
if (UserMMKV.currentUser.uid.isNotBlank() &&
UserMMKV.token.isNotBlank()
) {
login(UserMMKV.currentUser, UserMMKV.token)
} else {
logout()
}
}
fun logout() {
mLoginState = GuestState()
UserMMKV.currentUser = UserModel()
UserMMKV.token = ""
loginFlow.tryEmit(null)
}
fun login(userModel: UserModel, token: String) {
UserMMKV.currentUser = userModel
UserMMKV.token = token
mLoginState = LoginState()
loginFlow.tryEmit(userModel)
}
fun action(
context: LifecycleOwner,
requestLogin: Boolean = true,
loginParams: MutableMap<LoginParams, Any> = mutableMapOf(),
interceptBlock: Boolean = false,
block: (result: LoginResult) -> Unit
) {
val afterLoginAction = if (interceptBlock) EMPTY_BLOCK else block
mLoginState.action(context, requestLogin, loginParams, afterLoginAction)
}
private val EMPTY_BLOCK = { _: LoginResult -> }
}
context类中，我们提供了一个监听flow，用来观察登录状态变更，这里也可以替换成EventBus或者其他事件总线~
提供了login和logou方法用来切换ILoginState的实现接口及其他动作~~
提供了一个ILoginState的代理action方法，这里很好理解吧~
接下来我们来实现requestLogin扩展方法，这个实现思路类似权限工具设计
首先我们实现一个代理的fragment用来接收LoginActivity的回调
class LoginProxyFragment : Fragment() {
companion object {
private const val TAG = "LoginProxyFragmentTag"
fun getLoginProxyFragment(
activity: FragmentActivity,
block: (result: LoginResult) -> Unit
): LoginProxyFragment {
var loginProxyFragment = findLoginProxyFragment(activity)
if (loginProxyFragment == null) {
loginProxyFragment = LoginProxyFragment()
activity.supportFragmentManager.commit(true) {
add(loginProxyFragment, TAG)
}
}
loginProxyFragment.block = block
return loginProxyFragment
}
private fun findLoginProxyFragment(activity: FragmentActivity): LoginProxyFragment? {
return activity.supportFragmentManager.findFragmentByTag(TAG) as? LoginProxyFragment
}
}
private var block: (result: LoginResult) -> Unit = { }
private val launcher = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
when (it.data?.getStringExtra(K_LOGIN_RESULT) ?: R_LOGIN_UNKNOWN) {
R_LOGIN_SUCCESS -> {
block(LoginResult.Success())
}
R_LOGIN_CANCEL -> {
block(LoginResult.Cancel())
}
else -> {
block(LoginResult.UnKnown())
}
}
}
fun requestLogin(loginParams: MutableMap<LoginParams, Any> = mutableMapOf()) {
launchWhenResumed {
launcher.launch(Intent(requireActivity(), LoginActivity::class.java).apply {
loginParams.forEach { (k, v) ->
when (v) {
is String -> putExtra(k.key, v)
is Boolean -> putExtra(k.key, v)
is Int -> putExtra(k.key, v)
is Float -> putExtra(k.key, v)
is Long -> putExtra(k.key, v)
is Parcelable -> putExtra(k.key, v)
is Serializable -> putExtra(k.key, v)
else -> throw IllegalArgumentException("loginParams 不支持的类型")
}
}
})
}
}
}
然后实现lifecycleOwner的扩展方法，方便调用
fun LifecycleOwner.requestLogin(
loginParams: MutableMap<LoginParams, Any> = mutableMapOf(),
block: (result: LoginResult) -> Unit
) {
runCatching {
when (this@requestLogin) {
is FragmentActivity -> {
LoginProxyFragment.getLoginProxyFragment(this@requestLogin, block)
.requestLogin(loginParams)
}
is Fragment -> {
LoginProxyFragment.getLoginProxyFragment(this@requestLogin.requireActivity(), block)
.requestLogin(loginParams)
}
else -> {
throw RuntimeException("requestPermission LifecycleOwner必须是activity或fragment")
}
}
}.onFailure {
block(LoginResult.Cancel())
}
}
如此，我们便能够简单的调用LoginActivity并再调用后执行继续动作了。
例如:
requestLogin {
it.onSuccess {
//登录成功后执行~
}
}
当然，不要忘了我们的模块化方案，最终还是要在LoginProxy中代理执行的。
如此，我们便完成了一个优雅的登录模块设计~~~
完整代码：传送门
