Java 砂浆和流动的onActivityResult当量？

我正在寻找一种方法，可以在不丢失上一个屏幕中构建的内容的情况下，从使用的屏幕返回结果，类似于我对onActivityResult所做的操作。例如，这里有一个屏幕，我正在创建一个新文档：

@Layout(R.layout.new_document_view)
class NewDocumentScreen implements Blueprint {

  // Imagine some Blueprint boiler plate here

  static class Presenter implements ViewPresenter<NewDocumentView> {
    private final Flow flow;

    private Document newDocument = new Document();

    @Inject Presenter(Flow flow) { this.flow = flow; }

    @Override protected void onLoad(Bundle savedInstanceState) {
        super.onLoad(savedInstanceState);

        NewDocumentView view = getView();
        if (view == null) return;

        view.bindTo(newDocument);  // immediately reflect view changes in document
    }   

    // Imagine this is called by pressing a button in NewDocumentView
    public void chooseDocumentAuthor() {
      // What I want here is to navigate to the chooser screen, make my choice and
      // then return to this screen having set the author on the document.
      flow.goTo(new ChooseDocumentAuthorScreen());
    }
  }
}

@Layout（R.Layout.new\u document\u视图）
类NewDocumentScreen实现蓝图{
//想象一下这里有一个蓝图锅炉板
静态类Presenter实现ViewPresenter{
私人最终流量；
私有文档newDocument=新文档（）；
@注入演示者（流）{this.Flow=Flow；}
@覆盖受保护的void onLoad（Bundle savedInstanceState）{
super.onLoad（savedInstanceState）；
NewDocumentView=getView（）；
if（view==null）返回；
view.bindTo（newDocument）；//立即反映文档中的视图更改
}   
//想象一下，在NewDocumentView中按一个按钮就可以调用它
public void选择文档作者（）{
//我想在这里导航到选择器屏幕，做出选择并
//然后在文档上设置作者后返回此屏幕。
转到（新选择的DocumentAuthorScreen（））；
}
}
}

我该怎么做？我一直在尝试和，但没有太多关于这些的信息，我不相信这是正确的方式，因为选择器本身就是一个屏幕

更新–潜在解决方案

根据下面的答案，我做了以下工作，似乎效果不错：

TakesResult.java

public interface TakesResult<T> {
  // Called when receiving a result
  void onResult(T result);
}

公共接口获取结果{
//在收到结果时调用
无效结果（T结果）；
}

NewDocumentScreen.java

@Layout(R.layout.new_document_view)
class NewDocumentScreen implements Blueprint, TakesResult<Author> {

  private Document newDocument = new Document();      

  @Override public void onResult(Author result) {
    newDocument.setAuthor(result);
  }

  // Imagine some Blueprint boiler plate here

  @dagger.Module(injects = NewDocumentView.class, addsTo = MainScreen.Module.class)
  class Module {
    @Provides Document provideDocument() { return newDocument; }  
    @Provides NewDocumentScreen provideScreen() { return this; }
  }

  static class Presenter implements ViewPresenter<NewDocumentView> {
    private final Flow flow;
    private final NewDocumentScreen screen
    private final Document newDocument;

    @Inject Presenter(Flow flow, NewDocumentScreen screen, Document newDocument) { 
      this.flow = flow; 
      this.screen = screen;
      this.newDocument = newDocument;
    }

    @Override
    protected void onLoad(Bundle savedInstanceState) {
      // Stuff to update view
    }

    // Imagine this is called by the view
    public void chooseDocumentAuthor() {
      // Since screen TakesResult we send it to the ChooseAuthorScreen
      flow.goTo(new ChooseDocumentAuthorScreen(screen));
    }
  }
}

@Layout（R.Layout.new\u document\u视图）
类NewDocumentScreen实现Blueprint，TakesResult{
私有文档newDocument=新文档（）；
@覆盖公共void onResult（作者结果）{
newDocument.setAuthor（结果）；
}
//想象一下这里有一个蓝图锅炉板
@dagger.Module（injects=NewDocumentView.class，addsTo=MainScreen.Module.class）
类模块{
@提供文档提供的文档（）{return newDocument；}
@提供NewDocumentScreen provideScreen（）{返回此；}
}
静态类Presenter实现ViewPresenter{
私人最终流量；
私有最终NewDocumentScreen屏幕
私人最终文件；
@注入演示者（流、NewDocumentScreen屏幕、Document newDocument）{
这个。流量=流量；
this.screen=屏幕；
this.newDocument=newDocument；
}
@凌驾
受保护的void onLoad（Bundle savedInstanceState）{
//要更新视图的内容
}
//想象一下，这是由视图调用的
public void选择文档作者（）{
//由于屏幕截取结果，我们将其发送到ChooseAuthorsScreen
转到（新选择的文档作者屏幕（屏幕））；
}
}
}

选择authorscreen.java

@Layout(R.layout.choose_author_view)
class ChooseAuthorScreen implements Blueprint {
  private final TakesResult<Author> resultReceiver;

  ChooseAuthorScreen(TakesResult<Author> resultReceiver) {
    this.resultReceiver = resultReceiver;
  }

  // Imagine some Blueprint boiler plate here

  @dagger.Module(injects = ChooseAuthorView.class, addsTo = MainScreen.Module.class)
  class Module {
    @Provides TakesResult<Author> provideResultReceiver() { return resultReceiver; }  
  }

  static class Presenter implements ViewPresenter<ChooseAuthorView> {
    private final Flow flow;
    private final TakesResult<Author> resultReceiver;

    @Inject Presenter(Flow flow, TakesResult<Author> resultReceiver) { 
      this.flow = flow; 
      this.resultReceiver = resultReceiver;
    }

    // Imagine this is called by the view
    public void chooseAuthor(Author author) {
      resultReceiver.onResult(author);
      flow.goBack();
    }
  }
}

@Layout（R.Layout.选择作者视图）
类ChooseAuthorsScreen实现蓝图{
私人最终结果接收者；
选择作者或屏幕（获取结果结果接收器）{
this.resultReceiver=resultReceiver；
}
//想象一下这里有一个蓝图锅炉板
@dagger.Module（injects=ChooseAuthorView.class，addsTo=MainScreen.Module.class）
类模块{
@提供TakesResult ProviderResultReceiver（）{return resultReceiver；}
}
静态类Presenter实现ViewPresenter{
私人最终流量；
私人最终结果接收者；
@注入演示者（流，TakesResult resultReceiver）{
这个。流量=流量；
this.resultReceiver=resultReceiver；
}
//想象一下，这是由视图调用的
公共无效选择作者（作者）{
resultReceiver.onResult（作者）；
flow.goBack（）；
}
}
}
弹出窗口和PopupPresenter可能是个错误。我见过的一种更好的技术是让“对话”屏幕将其结果写入流backbackback中前一个屏幕对象上的已知瞬态场。一方面，这看起来很粗糙。另一方面，它非常简单，可读性很强
 很有趣，谢谢。我看到你在GitHub上的一期文章中说过这样的话。我会试一试，让你知道我的进展如何。我刚刚为上述问题添加了一个潜在的解决方案，我采纳了你的建议，但添加了一个接口，以使两者之间的关系正式化。想法？可能会有这样的情况，背驮被杀死，并从包裹中重建。在这种情况下，
resultReceiver
很可能是
null
。所以我这样做（（TakesResult）（flow.getBackstack（）.reverseIterator（）.next（）.getScreen（）））.onResult（t）我还有一个例子，当用户按下后退按钮时，结果应该被传递，所以我在
onExitScope（）