public interface ActivityResultCaller {
  @NonNull
  <I, O> ActivityResultLauncher<I> prepareCall(
      @NonNull ActivityResultContract<I, O> contract,
      @NonNull ActivityResultCallback<O> callback);
  // ▶ ActivityResultCaller를 구현한 곳에서 ActivityResultRegistry 객체를 이용

  @NonNull
  <I, O> ActivityResultLauncher<I> prepareCall(
      @NonNull ActivityResultContract<I, O> contract,
      @NonNull ActivityResultRegistry registry,
      @NonNull ActivityResultCallback<O> callback);
}

public interface ActivityResultLauncher<I> {
  void launch(@SuppressLint("UnknownNullness") I input);

  void dispose();
}

public final class ActivityResult implements Parcelable {
    private final int mResultCode;
    @Nullable
    private final Intent mData;
}

void onActivityResult (int requestCode, int resultCode, Intent data)

public abstract class ActivityResultContract<I, O> {
  public abstract @NonNull Intent createIntent(@SuppressLint("UnknownNullness") I input);
  
  public abstract @SuppressLint("UnknownNullness") O parseResult(
      int resultCode,
      @Nullable Intent intent);
}

public class ActivityResultContracts {
  private ActivityResultContracts() {}
  ...
  public static class StartActivityForResult
      extends ActivityResultContract<Intent, ActivityResult> {

   @NonNull
   @Override
   public Intent createIntent(@NonNull Intent input) {
     return input;
   }

   @NonNull
   @Override
   public ActivityResult parseResult(int resultCode, @Nullable Intent intent) {
     return new ActivityResult(resultCode, intent);
   }
  }
  ...
  public static class Dial extends ActivityResultContract<String, Boolean> {
    @NonNull
    @Override
    public Intent createIntent(@NonNull String input) {
      return new Intent(Intent.ACTION_DIAL).setData(Uri.parse("tel:" + input));
    }
  
    @NonNull
    @Override
    public Boolean parseResult(int resultCode, @Nullable Intent intent) {
      return resultCode == Activity.RESULT_OK;
    }
  }
  ...
}

public class ActivityResultContracts {
  private ActivityResultContracts() {}
  ...
  public static final String ACTION_REQUEST_PERMISSIONS =
      "androidx.activity.result.contract.action.REQUEST_PERMISSIONS";

  public static final String EXTRA_PERMISSIONS =
      "androidx.activity.result.contract.extra.PERMISSIONS";

  public static final String EXTRA_PERMISSION_GRANT_RESULTS =
      "androidx.activity.result.contract.extra.PERMISSION_GRANT_RESULTS";  
  ... 
  public static class RequestPermission extends ActivityResultContract<String, Boolean> {

    @NonNull
    @Override
    public Intent createIntent(@NonNull String input) {
      return new Intent(ACTION_REQUEST_PERMISSIONS)
          .putExtra(EXTRA_PERMISSIONS, new String[] { input });
    }

    @NonNull
    @Override
    public Boolean parseResult(int resultCode, @Nullable Intent intent) {
      if (resultCode != Activity.RESULT_OK) return false;
      if (intent == null) return false;
      int[] grantResults = intent.getIntArrayExtra(EXTRA_PERMISSION_GRANT_RESULTS);
      if (grantResults == null) return false;
      return grantResults[0] == PackageManager.PERMISSION_GRANTED;
    }
  }
  ...
}

public abstract class ActivityResultRegistry {
    ...
    private final AtomicInteger mNextRc = new AtomicInteger(0);
    private final Map<Integer, String> mRcToKey = new HashMap<Integer, String>();
    private final Map<String, Integer> mKeyToRc = new HashMap<String, Integer>();
    private final transient Map<String, CallbackAndContract<?>> mKeyToCallback =
            new HashMap<String, CallbackAndContract<?>>();
    private final Bundle/*<String, ActivityResult>*/ mPendingResults = new Bundle();

    @MainThread
    public abstract <I, O> void invoke(
            int requestCode,
            @NonNull ActivityResultContract<I, O> contract,
            @SuppressLint("UnknownNullness") I input);
 
    @NonNull
    public <I, O> ActivityResultLauncher<I> registerActivityResultCallback(
            @NonNull final String key,
            @NonNull final LifecycleOwner lifecycleOwner,
            @NonNull final ActivityResultContract<I, O> contract,
            @NonNull final ActivityResultCallback<O> callback) {
        final int requestCode = registerKey(key);
        mKeyToCallback.put(key, new CallbackAndContract<O>(callback, contract));
        Lifecycle lifecycle = lifecycleOwner.getLifecycle();
        final ActivityResult pendingResult = mPendingResults.getParcelable(key);
        if (pendingResult != null) {
            mPendingResults.remove(key);
            if (lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
                callback.onActivityResult(contract.parseResult(
                        pendingResult.getResultCode(),
                        pendingResult.getData()));
            } else {
                lifecycle.addObserver(new LifecycleEventObserver() {
                    @Override
                    public void onStateChanged(
                            @NonNull LifecycleOwner lifecycleOwner,
                            @NonNull Lifecycle.Event event) {
                        if (Lifecycle.Event.ON_CREATE.equals(event)) {
                            callback.onActivityResult(contract.parseResult(
                                    pendingResult.getResultCode(),
                                    pendingResult.getData()));
                        }
                    }
                });
            }
        }
        lifecycle.addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
                    @NonNull Lifecycle.Event event) {
                if (Lifecycle.Event.ON_DESTROY.equals(event)) {
                    unregisterActivityResultCallback(key);
                }
            }
        });
        return new ActivityResultLauncher<I>() {
            @Override
            public void launch(I input) {
                invoke(requestCode, contract, input);
            }
            @Override
            public void dispose() {
                unregisterActivityResultCallback(key);
            }
        };
    }

    @NonNull
    public <I, O> ActivityResultLauncher<I> registerActivityResultCallback(
            @NonNull final String key,
            @NonNull final ActivityResultContract<I, O> contract,
            @NonNull final ActivityResultCallback<O> callback) {
        final int requestCode = registerKey(key);
        mKeyToCallback.put(key, new CallbackAndContract<O>(callback, contract));
        final ActivityResult pendingResult = mPendingResults.getParcelable(key);
        if (pendingResult != null) {
            mPendingResults.remove(key);
            callback.onActivityResult(contract.parseResult(
                    pendingResult.getResultCode(),
                    pendingResult.getData()));
        }
        return new ActivityResultLauncher<I>() {
            @Override
            public void launch(I input) {
                invoke(requestCode, contract, input);
            }
            @Override
            public void dispose() {
                unregisterActivityResultCallback(key);
            }
        };
    }
    ...
    @MainThread
    public boolean dispatchResult(int requestCode, int resultCode, @Nullable Intent data) {
        String key = mRcToKey.get(requestCode);
        if (key == null) {
            return false;
        }
        doDispatch(key, resultCode, data, mKeyToCallback.get(key));
        return true;
    }
    private <O> void doDispatch(String key, int resultCode, @Nullable Intent data,
            CallbackAndContract<O> callbackAndContract) {
        ActivityResultCallback<O> callback = callbackAndContract.mCallback;
        ActivityResultContract<?, O> contract = callbackAndContract.mContract;
        if (callback != null) {
            callback.onActivityResult(contract.parseResult(resultCode, data));
        } else {
            mPendingResults.putParcelable(key, new ActivityResult(resultCode, data));
        }
    }
    ...
    private int registerKey(String key) {
        Integer existing = mKeyToRc.get(key);
        if (existing != null) {
            return existing;
        }
        int rc = mNextRc.getAndIncrement();
        bindRcKey(rc, key);
        return rc;
    }
    ...
}