手把手教你搭建android项目框架（九）小试牛刀——优雅的登录方案

你是否厌倦了这种写法？

kotlin 复制代码

        if (UserManager.isLogin()) {
               do something.....
               .....
        } else {
               do something......
              .....
       }

亦或是这种写法？

kotlin 复制代码

     if (!UserManager.isLogin()) {
           callLogin{
                if(success){
                      do something......
                      .... 
                }
          }     
     }

那么今天，我将给你一个优雅的登录实现方案~

说到登录，我们不得不聊到一个设计模式------状态模式，顾名思义，他是专门用来处理不同状态的不同动作的设计模式。

他的类图是这样子的。

简单理解，就是借助通过接口的实现类，实现不同状态下的同一个动作，然后借助context类统一处理。非常好理解，这里不多说，不懂的可以看传送门

那么我们今天就借助状态模式来实现一个登录方案吧~

老规矩，先看效果~

处理登录、匿名状态下的不同动作，如点击某个按钮，弹出窗口不一致时，我们可以分别在Success,guest中处理登录或者游客不同的跳转等。

kotlin 复制代码

          //模块化代理类，不懂的请看本系列模块化讲解部分
          LoginProxy.action(this, false) {
            it.onSuccess {
                这里处理登录状态下的某个动作，如不同的ui，点击按钮不同的反馈等
                //do something 
            }
            it.onGuest {
                这里处理注销状态下的某个动作，如不同的ui，点击按钮不同的反馈等
            }
        }

某个动作需要登录，然后继续执行操作等，例如点击评论按钮->弹出登录页面->登录成功后弹出评论弹框等

kotlin 复制代码

       LoginProxy.action(this) {
            it.onSuccess {
                弹出评论弹框
            }
            it.onCancel { 
                用户取消登录，如不使用，可以忽略
            }
        }

接下来我们一步一步实现这个方案吧~

首先是我们聊到的状态模式，这里直接给出代码参考

首先是接口

kotlin 复制代码

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
    )
}

然后我们给出两个实现类，即登录状态和游客状态

kotlin 复制代码

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管理类，统一我们的整合条件

kotlin 复制代码

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的回调

kotlin 复制代码

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的扩展方法，方便调用

kotlin 复制代码

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并再调用后执行继续动作了。

例如:

kotlin 复制代码

      requestLogin {
            it.onSuccess { 
                //登录成功后执行~
            }
        }

当然，不要忘了我们的模块化方案，最终还是要在LoginProxy中代理执行的。

如此，我们便完成了一个优雅的登录模块设计~~~

完整代码：传送门