Flutter 使用一个集团，一个国家的页面分割形式？

我有一个单一表单，根据用户体验和用户界面设计要求将其分为3页。结构如下所示：

MyApp
  |
  |- BlocProvider.of<MyBloc>(context)
      |- PageA
      |    |- FormA
      |         |- InputA
      |         |- InputB
      |         |- InputC
      |         |- RaisedButton (Next button)
      |
      |- PageB
      |    |- FormA
      |         |- InputD
      |         |- InputE
      |         |- InputF
      |         |- RaisedButton (Back button)
      |         |- RaisedButton (Next button)
      |
      |- PageC
      |    |- FormA
      |         |- InputG
      |         |- InputH
      |         |- InputI
      |         |- RaisedButton (Back button)
      |         |- RaisedButton (Submit button)

MyApp
|
|-BlocProvider.of（上下文）
|-佩加
||-形式
||-输入
||-输入b
||-InputC
||-升起按钮（下一个按钮）
|
|-PageB
||-形式
||-输入
||-输入
||-输入
||-升起按钮（后退按钮）
||-升起按钮（下一个按钮）
|
|-佩奇
||-形式
||-输入
||-InputH
||-InputI
||-升起按钮（后退按钮）
||-升起按钮（提交按钮）

我希望传递相同的状态，并更新

RaisedButton

按钮的状态数据

onPressed

，而无需将我的树包装在

blocbuilder、bloclistener

或

blocconsumer

中，因为不需要在状态更改时重建小部件

我该怎么做

注意

• 每个表单都是一个页面，而不是选项卡栏或页面视图
• 我只希望在整个页面上共享一个bloc和一个state，而不是每页共享一个bloc
• 我想要这种行为仅仅是因为我实际上避免了从构造函数传递数据
• 已尝试

  BlocProvider.of（context）.state

  ，但它不允许我访问该对象

---

我举了一个很简单的例子，希望能对你有所帮助

import 'package:equatable/equatable.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (_) => MyForm(),
      child: MaterialApp(
        title: 'Flutter Demo',
        home: HomePage(),
      ),
    );
  }
}

class HomePage extends StatelessWidget {
  Widget build(BuildContext context) {
    return Scaffold(
      body: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        crossAxisAlignment: CrossAxisAlignment.stretch,
        children: [
          BlocBuilder<MyForm, MyFromState>(
            builder: (_, state) {
              return Column(
                mainAxisAlignment: MainAxisAlignment.center,
                crossAxisAlignment: CrossAxisAlignment.center,
                children: [
                  Text('inputA: ${state.inputA}'),
                  Text('inputB: ${state.inputB}'),
                  Text('inputC: ${state.inputC}'),
                  Text('inputD: ${state.inputD}'),
                  Text('inputE: ${state.inputE}'),
                  Text('inputF: ${state.inputF}'),
                ],
              );
            },
          ),
          Center(
            child: RaisedButton(
              onPressed: () {
                Navigator.push(
                  context,
                  MaterialPageRoute(builder: (context) => FirstPage()),
                );
              },
              child: Text('start'),
            ),
          ),
        ],
      ),
    );
  }
}

class FirstPage extends StatelessWidget {
  Widget build(BuildContext context) {
    var bloc = BlocProvider.of<MyForm>(context);
    return Scaffold(
      body: Center(
        child: RaisedButton(
          onPressed: () {
            bloc.add(FirstPageSubmitEvent(
              inputA: 'text1',
              inputB: 'text2',
            ));
            Navigator.push(
              context,
              MaterialPageRoute(builder: (context) => SecondPage()),
            );
          },
          child: Text('page 2'),
        ),
      ),
    );
  }
}

class SecondPage extends StatelessWidget {
  Widget build(BuildContext context) {
    var bloc = BlocProvider.of<MyForm>(context);
    return Scaffold(
      body: Center(
        child: RaisedButton(
          onPressed: () {
            bloc.add(SecondPageSubmitEvent(
              inputC: 'text3',
              inputD: 'text4',
            ));
            Navigator.push(
              context,
              MaterialPageRoute(builder: (context) => ThirdPage()),
            );
          },
          child: Text('page 3'),
        ),
      ),
    );
  }
}

class ThirdPage extends StatelessWidget {
  Widget build(BuildContext context) {
    var bloc = BlocProvider.of<MyForm>(context);
    return Scaffold(
      body: Center(
        child: RaisedButton(
          onPressed: () {
            bloc.add(ThirdPageSubmitEvent(
              inputE: 'text5',
              inputF: 'text6',
            ));
            Navigator.pushAndRemoveUntil(
              context,
              MaterialPageRoute(builder: (context) => HomePage()),
              (r) => r == null,
            );
          },
          child: Text('page 3'),
        ),
      ),
    );
  }
}

class MyForm extends Bloc<MyFormEvent, MyFromState> {
  MyForm() : super(MyFromState.empty);

  @override
  Stream<MyFromState> mapEventToState(MyFormEvent event) async* {
    if (event is FirstPageSubmitEvent) {
      yield (state.copyWith(
        inputA: event.inputA,
        inputB: event.inputB,
      ));
    } else if (event is SecondPageSubmitEvent) {
      yield (state.copyWith(
        inputC: event.inputC,
        inputD: event.inputD,
      ));
    } else if (event is ThirdPageSubmitEvent) {
      yield (state.copyWith(
        inputE: event.inputE,
        inputF: event.inputF,
      ));
    }
  }
}

abstract class MyFormEvent extends Equatable {}

class FirstPageSubmitEvent extends MyFormEvent {
  FirstPageSubmitEvent({this.inputA, this.inputB});

  final String inputA;
  final String inputB;

  @override
  List<Object> get props => [inputA, inputB];
}

class SecondPageSubmitEvent extends MyFormEvent {
  SecondPageSubmitEvent({this.inputC, this.inputD});

  final String inputC;
  final String inputD;

  @override
  List<Object> get props => [inputC, inputD];
}

class ThirdPageSubmitEvent extends MyFormEvent {
  ThirdPageSubmitEvent({this.inputE, this.inputF});

  final String inputE;
  final String inputF;

  @override
  List<Object> get props => [inputE, inputF];
}

class MyFromState extends Equatable {
  final String inputA;
  final String inputB;
  final String inputC;
  final String inputD;
  final String inputE;
  final String inputF;

  const MyFromState({
    this.inputA,
    this.inputB,
    this.inputC,
    this.inputD,
    this.inputE,
    this.inputF,
  });

  static const empty = MyFromState(
    inputA: '',
    inputB: '',
    inputC: '',
    inputD: '',
    inputE: '',
    inputF: '',
  );

  MyFromState copyWith({
    String inputA,
    String inputB,
    String inputC,
    String inputD,
    String inputE,
    String inputF,
  }) {
    return MyFromState(
      inputA: inputA ?? this.inputA,
      inputB: inputB ?? this.inputB,
      inputC: inputC ?? this.inputC,
      inputD: inputD ?? this.inputD,
      inputE: inputE ?? this.inputE,
      inputF: inputF ?? this.inputF,
    );
  }

  @override
  List<Object> get props => [inputA, inputB, inputC, inputD, inputE, inputF];
}

import'包：equalable/equalable.dart'；
进口“包装：颤振/材料.省道”；
进口“包装：颤振团/颤振团.飞镖”；
void main（）=>runApp（MyApp（））；
类MyApp扩展了无状态小部件{
@凌驾
小部件构建（构建上下文）{
返回BlocProvider(
创建：（）=>MyForm（），
孩子：MaterialApp(
标题：“颤振演示”，
主页：主页（），
),
);
}
}
类主页扩展了无状态小部件{
小部件构建（构建上下文）{
返回脚手架(
正文：专栏(
mainAxisAlignment:mainAxisAlignment.center，
crossAxisAlignment:crossAxisAlignment.stretch，
儿童：[
BlocBuilder(
建筑商：（u，州）{
返回列(
mainAxisAlignment:mainAxisAlignment.center，
crossAxisAlignment:crossAxisAlignment.center，
儿童：[
Text（'inputA:${state.inputA}'），
Text（'inputB:${state.inputB}'），
Text（'inputC:${state.inputC}'），
Text（'inputD:${state.inputD}'），
Text（'inputE:${state.inputE}'），
Text（'inputF:${state.inputF}'），
],
);
},
),
居中(
孩子：升起按钮(
已按下：（）{
导航器。推(
上下文
MaterialPage路由（生成器：（上下文）=>FirstPage（）），
);
},
子项：文本（'start'），
),
),
],
),
);
}
}
类FirstPage扩展了无状态小部件{
小部件构建（构建上下文）{
var bloc=BlocProvider.of（上下文）；
返回脚手架(
正文：中(
孩子：升起按钮(
已按下：（）{
bloc.add（第一页提交事件）(
输入：“text1”，
inputB:'text2'，
));
导航器。推(
上下文
MaterialPage路由（生成器：（上下文）=>SecondPage（）），
);
},
子项：文本（“第2页”），
),
),
);
}
}
类SecondPage扩展了无状态小部件{
小部件构建（构建上下文）{
var bloc=BlocProvider.of（上下文）；
返回脚手架(
正文：中(
孩子：升起按钮(
已按下：（）{
集团添加（第二页提交事件）(
inputC:'text3'，
输入：“text4”，
));
导航器。推(
上下文
MaterialPageRoute（生成器：（上下文）=>ThirdPage（）），
);
},
子项：文本（“第3页”），
),
),
);
}
}
类ThirdPage扩展了无状态小部件{
小部件构建（构建上下文）{
var bloc=BlocProvider.of（上下文）；
返回脚手架(
正文：中(
孩子：升起按钮(
已按下：（）{
集团添加（第三页提交事件）(
输入：“text5”，
inputF:'text6'，
));
Navigator.pushandremove直到(
上下文
MaterialPackageRoute（生成器：（上下文）=>HomePage（）），
（r） =>r==null，
);
},
子项：文本（“第3页”），
),
),
);
}
}
类MyForm扩展了Bloc{
MyForm（）：super（MyFromState.empty）；
@凌驾
流mapEventToState（MyFormEvent事件）异步*{
如果（事件为FirstPageSubmitEvent）{
收益率（state.copyWith）(
输入：event.inputA，
inputB:event.inputB，
));
}else if（事件为SecondPageSubmitEvent）{
收益率（state.copyWith）(
inputC:event.inputC，
inputD:event.inputD，
));
}else if（事件为第三页提交事件）{
收益率（state.copyWith）(
输入：event.input，
inputF:event.inputF，
));
}
}
}
抽象类MyFormEvent扩展了可等式{}
类FirstPageSubmitEvent扩展MyFormEvent{
FirstPageSubmitEvent（{this.inputA，this.inputB}）；
最终字符串输入；
最终字符串输入b；
@凌驾
列表获取道具=>[inputA，inputB]；
}
类SecondPageSubmitEvent扩展MyFormEvent{
SecondPageSubmitEvent（{this.inputUTC，this.inputD}）；
最终字符串输入UTC；
最终字符串输入；
@凌驾
列表获取道具=>[inputC