在开发过程中是否遇到这么一个问题，功能描述：点击后执行一段代码，但是要在点击的时候检测是否已登录。这个功能很简单，但登录后要继续执行刚才那段代码呢？是不是有点无头绪了。在Java中可以用接口去回调，但触发的时间又是在登录完成后。怎么办？

其实对LifecycleObserver有了解的，大概都有思路了。LifecycleObserver是对Activity和Fragment的生命周期进行监听，以便在特定的生命周期内作出相关操作。思考下，我们点击后取到登录界面，登录回来的Activity是不是走了onResume呢，那么登录成功后，再走后续的方法：

public class LoginIntercept implements LifecycleObserver {
    private BlockIntentFun blockIntentFun;

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void resume(){
        if (BaseApplication.getInstance().isLogin){
            if (blockIntentFun != null){
                blockIntentFun.execute();
            }
            blockIntentFun = null;
        }
    }

    public void setBlockIntentFun(BlockIntentFun blockIntentFun) {
        this.blockIntentFun = blockIntentFun;
    }

    public interface BlockIntentFun{
        void execute();
    }
}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME) 的意思是在onResume的时候执行下面方法，方法名可以随便定；因为每次onResume的时候都会走这个方法，所以执行完要置空，不然每次都会被调用。

在Activity中，需要注册生命周期的监听，分别在onStart和onDestroy加上监听和移除监听。

public class InterceptActivity extends AppCompatActivity {
    private LoginIntercept intercept;
    private TextView textView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.intercept_activity);
        intercept = new LoginIntercept();
        textView = findViewById(R.id.text);
        textView.setOnClickListener(v -> loginCheck());
    }

    @Override
    protected void onStart() {
        super.onStart();
        getLifecycle().addObserver(intercept);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        getLifecycle().removeObserver(intercept);
    }

    private void doSomething(){
        //点击后要做的事
    }

    private void loginCheck(){
        //需要获取登录状态，按自己需求设定
        if (BaseApplication.getInstance().isLogin){
            doSomething();
        }else{
            intercept.setBlockIntentFun(this::doSomething);
            startActivity(new Intent(getApplicationContext(),LoginActivity.class));
            //这里假设登录成功了，实际操作按自己的逻辑来处理
            BaseApplication.getInstance().isLogin = true;
        }
    }
}

这样就解决了，每次只在点击的时候调用了；假如用Kotlin的话，会方便很多，前提是对Kotlin的高阶函数有了解

class LoginInterceptKt : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume(){
        if (BaseApplication.getInstance().isLogin){
            blockIntercept?.invoke()
        }
        blockIntercept = null
    }
}

private var blockIntercept: (() -> Unit)? = null
fun loginCheck(activityKt: InterceptActivityKt,block:(() -> Unit)?){
    if (BaseApplication.getInstance().isLogin){
        //如果登录了就不拦截，直接执行
        block?.invoke()
    }else{
        activityKt.startActivity(Intent(activityKt,LoginActivity::class.java))
        //这里假设登录成功了，实际按自己需求来处理
        blockIntercept = block
    }
}

用Kotlin的方式写看起来更简洁点，用高阶函数取代了回调的功能。

class InterceptActivityKt : AppCompatActivity() {
    private val intercept by lazy { LoginInterceptKt() }

    override fun onStart() {
        super.onStart()
        lifecycle.addObserver(intercept)
    }

    override fun onDestroy() {
        super.onDestroy()
        lifecycle.removeObserver(intercept)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.intercept_activity)
        text.setOnClickListener {
            loginCheck(this) {
                doSomething()
            }
        }
    }

    private fun doSomething(){
        //点击后要做的事
    }
}

解决这个问题的方法可能有多种，但用这个方法解决的话，要对LifecycleObserver有了解。