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

你是否厌恶了这种写法？

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

亦或是这种写法？

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

那么今日，我将给你一个高雅的登录完成计划~

提到登录，咱们不得不聊到一个规划形式——状况形式，望文生义，他是专门用来处理不同状况的不同动作的规划形式。

他的类图是这姿态的。

简略了解，便是凭借经过接口的完成类，完成不同状况下的同一个动作，然后凭借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中署理履行的。

如此，咱们便完成了一个高雅的登录模块规划~~~

完好代码：传送门