registerForActivityResult的用法

Intent intent = new Intent();
registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), new ActivityResultCallback<ActivityResult>() {
    @Override
    public void onActivityResult(ActivityResult result) {
        
    }
}).launch(intent);

报错内容

registerLifecycleOwners must call register before they are STARTED.

这句报错的意思时，

生命周期所有者必须在开始之前调用

???但如果我们要在onPause或者onStop或者onDestroy中启动下一个activity该怎么办？

解决方案

在onStart或者onCreate中先创建

private ActivityResultLauncher<Intent> activityResultLauncher;

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    activityResultLauncher = registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), result -> {
        if (Settings.canDrawOverlays(BabyProMainActivity.this)) {
            sendBroadcast();
        }
    });
}

然后在需要启动activity的位置添加

Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
activityResultLauncher.launch(intent);

这样运行就完成了在本页面生命周期结束的位置开启新的activity。

原因分析(跟踪源码)

@NonNull
@Override
public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
        @NonNull ActivityResultContract<I, O> contract,
        @NonNull ActivityResultCallback<O> callback) {
    return registerForActivityResult(contract, mActivityResultRegistry, callback);
}

@NonNull
@Override
public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
        @NonNull final ActivityResultContract<I, O> contract,
        @NonNull final ActivityResultRegistry registry,
        @NonNull final ActivityResultCallback<O> callback) {
    return registry.register(
            "activity_rq#" + mNextLocalRequestCode.getAndIncrement(), this, contract, callback);
}

@NonNull
public final <I, O> ActivityResultLauncher<I> register(
        @NonNull final String key,
        @NonNull final LifecycleOwner lifecycleOwner,
        @NonNull final ActivityResultContract<I, O> contract,
        @NonNull final ActivityResultCallback<O> callback) {
    Lifecycle lifecycle = lifecycleOwner.getLifecycle();
    if (lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
        throw new IllegalStateException("LifecycleOwner " + lifecycleOwner + " is "
                + "attempting to register while current state is "
                + lifecycle.getCurrentState() + ". LifecycleOwners must call register before "
                + "they are STARTED.");
    }
    final int requestCode = registerKey(key);
    LifecycleContainer lifecycleContainer = mKeyToLifecycleContainers.get(key);
    if (lifecycleContainer == null) {
        lifecycleContainer = new LifecycleContainer(lifecycle);
    }
    LifecycleEventObserver observer = new LifecycleEventObserver() {
        @Override
        public void onStateChanged(
                @NonNull LifecycleOwner lifecycleOwner,
                @NonNull Lifecycle.Event event) {
            if (Lifecycle.Event.ON_START.equals(event)) {
                mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
                if (mParsedPendingResults.containsKey(key)) {
                    @SuppressWarnings("unchecked")
                    final O parsedPendingResult = (O) mParsedPendingResults.get(key);
                    mParsedPendingResults.remove(key);
                    callback.onActivityResult(parsedPendingResult);
                }
                final ActivityResult pendingResult = mPendingResults.getParcelable(key);
                if (pendingResult != null) {
                    mPendingResults.remove(key);
                    callback.onActivityResult(contract.parseResult(
                            pendingResult.getResultCode(),
                            pendingResult.getData()));
                }
            } else if (Lifecycle.Event.ON_STOP.equals(event)) {
                mKeyToCallback.remove(key);
            } else if (Lifecycle.Event.ON_DESTROY.equals(event)) {
                unregister(key);
            }
        }
    };
    lifecycleContainer.addObserver(observer);
    mKeyToLifecycleContainers.put(key, lifecycleContainer);
    return new ActivityResultLauncher<I>() {
        @Override
        public void launch(I input, @Nullable ActivityOptionsCompat options) {
            mLaunchedKeys.add(key);
            Integer innerCode = mKeyToRc.get(key);
            onLaunch((innerCode != null) ? innerCode : requestCode, contract, input, options);
        }
        @Override
        public void unregister() {
            ActivityResultRegistry.this.unregister(key);
        }
        @NonNull
        @Override
        public ActivityResultContract<I, ?> getContract() {
            return contract;
        }
    };
}

在源码中发现了抛异常的位置

if (lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
    throw new IllegalStateException("LifecycleOwner " + lifecycleOwner + " is "
            + "attempting to register while current state is "
            + lifecycle.getCurrentState() + ". LifecycleOwners must call register before "
            + "they are STARTED.");
}

意思是，注册的必须要在start或者其之前完成。

这也是为何解决方案中ActivityResultLauncher<Intent> activityResultLauncher放在onStart或者onCreate中完成的原因。