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

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

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

          //模块化代理类，不懂的请看本系列模块化讲解部分
          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())
        }
    }
}

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

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 不支持的类型")
                    }
                }
            })
        }
    }
}

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

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