Bolt 的 Flutter 路由管理实践（页面解耦，流程控制、功能拓展等） | Joker's Blog

onPressed: () {
  finalResult.setInput(_getCollectedInput());
  Navigator.push(
    context,
    MaterialPageRoute(builder: (context) => NextPage(finalResult)),
  );
}

onPressed: () {
  final input = _getCollectedInput();
  if (_isInEditMode) {
      _updateProfile(input);
  } else {
      _navigateToNextScreen();
  }
}

abstract class LocationInputScreenListener {

void onLocationEntered(LocationModel input);

void onBackPressed();
}

onPressed: () {
  final input = _getCollectedInput();
  _getListener().onLocationEntered(input);
}

abstract class LocationInputScreenListener<T extends StatefulWidget> implements State<T> {

void onLocationEntered(LocationModel input);

void onBackPressed();
}

class AncestorState extends State<AncestorWidget>
    implements
        LocationInputScreenListener<AncestorWidget>

class _ProfilePageState extends LifecycleAwareState<ProfilePage> {

Widget _buildEditProfileButton() {
    return DesignClickableText(
        text: 'Edit profile',
        onPressed: () => _editClickListener().onEditProfileClicked(),
        textStyle: Design.textCaption(color: Design.colorPrimary.shade900, bold: true),
        padding: EdgeInsets.all(8)
    );
  }

Widget _buildLogOutButton() {
    return DesignHorizontalMargin(DesignDangerButton(
        text: 'Log out',
        onPressed: () => _logOutListener().onLoggedOut()
    ));
  }

OnLoggedOutListener _logOutListener() {
    return context.findAncestorStateOfType<OnLoggedOutListener>();
  }

OnEditProfileClickedListener _editClickListener() {
    return context.findAncestorStateOfType<OnEditProfileClickedListener>();
  }
}

abstract class FlowControllerState<T extends StatefulWidget> extends State<T> {

GlobalKey<NavigatorState> _navKey;
  RouteObserver _routeObserver;
  List<String> _navStack;

@override
  void initState() {
    super.initState();
    _navStack = [];
    _navKey = GlobalObjectKey<NavigatorState>(this);
    _routeObserver = RouteObserver();
  }

AppPage createInitialPage();

@override
  Widget build(BuildContext context) {
    return Navigator(
        key: _navKey,
        observers: [_routeObserver],
        onGenerateRoute: (s) {
          AppPage page = createInitialPage();
          _navStack.add(page.name);
          return _buildRoute((s) => page.widget, page.name);
        });
  }

Route<R> _buildRoute<R>(WidgetBuilder builder, String name) {
    return CupertinoPageRoute(
        builder: builder, 
        settings: RouteSettings(name: name)
    );
  }
}

bool containsChild(String routeName) => _navStack.any((element) => element == routeName);

bool isDisplayed(String routeName) => _navStack.last == routeName;

void pushSimple(Widget Function() builder, String name) {
  push(_buildRoute((c) => builder(), name));
}

void pop<T>({T result}) {
  _navStack.removeLast();
  _navigator().pop(result);
}

Future<R> push<R>(Route<R> route) {
  assert(route.settings.name != null);
  _navStack.add(route.settings.name);
  return _navigator().push(route);
}

void popUntilFound(String name) {
  _navigator().popUntil((route) {
    final willPop = route.settings.name != name;
    if (willPop) _navStack.removeLast();
    return !willPop;
  });
}

abstract class LifecycleAwareState<T extends StatefulWidget> extends State<T> with WidgetsBindingObserver, RouteAware {

RouteObserver _routeObserver;
  void onResumed();

void onPaused();

@override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _isResumed = true;
    _isAppInFg = true;
    _isCovered = false;
    onResumed();
  }

@override
  void didChangeDependencies() {
    super.didChangeDependencies();

_unsubscribeFromStates();
    _routeObserver = _flowController()?.routeObserver();
    _routeObserver?.subscribe(this, ModalRoute.of(context));
  }

@override
  void dispose() {
    super.dispose();

_unsubscribeFromStates();
    WidgetsBinding.instance.removeObserver(this);
  }

void _unsubscribeFromStates() {
    _routeObserver?.unsubscribe(this);
    _routeObserver = null;
  }

FlowControllerState _flowController() => context.findAncestorStateOfType<FlowControllerState>();
}

@override
void onResumed() {
  setState(() {});
}

abstract class PopScopeHost<T extends StatefulWidget> implements State<T> {

List<BackPressHandler> _backPressHandlers = [];

Future<bool> onWillPop() async {
    for (int i = _backPressHandlers.length - 1; i >= 0; i--) {
      if (!_backPressHandlers[i].mounted) continue;
      if (_backPressHandlers[i].handleBackPressed()) {
        return false;
      }
    }
    return true;
  }

static PopScopeHostSubscription subscribe(BuildContext ctx, BackPressHandler handler) {
    final host = ctx.findAncestorStateOfType<PopScopeHost>();
    host.addBackPressHandler(handler);
    return PopScopeHostSubscription(host, handler);
  }
}

class PopScopeHostSubscription {
  PopScopeHost _host;
  BackPressHandler _handler;

PopScopeHostSubscription(this._host, this._handler);

void dispose() {
    _host?.removeBackPressHandler(_handler);
    _host = null;
  }
}

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  _popScopeHostSubscription?.dispose();
  _popScopeHostSubscription = PopScopeHost.subscribe(context, this);
}

@override
void dispose() {
  _popScopeHostSubscription?.dispose();
  super.dispose();
}

class RootState extends State<RootPage> with PopScopeHost<RootPage> {
  @override
  Widget build(BuildContext context) {
    return WillPopScope(
        onWillPop: onWillPop,
        child: _isLoggedIn ? 
            LoggedInFlowController() : 
            LoggedOutFlowController()
    );
  }
}

class _ProfileSetupControllerState extends FlowControllerState<ProfileSetupController> 
  implements 
      HobbyCategoryPageListener<ProfileSetupController>, 
      HobbyPageListener<ProfileSetupController>, 
      LanguagesPageListener<ProfileSetupController>, 
      LocationPageListener<ProfileSetupController> {

List<Hobby> _selectedHobbies;
  LocationModel _enteredLocation;

@override
  AppPage createInitialPage() => AppPage(_PAGE_HOBBY_CATEGORY, _createHobbyCategoryPage());

@override
  void onHobbyCategorySelected(HobbyCategory category) {
    pushSimple(() => _createHobbyPage(category.hobbies), _PAGE_HOBBY);
  }

@override
  void onHobbiesSelected(List<Hobby> hobbies) {
    _selectedHobbies = hobbies;
    pushSimple(() => _createLocationPage(), _PAGE_LOCATION);
  }

@override
  void onLocationEntered(LocationModel location) {
    _enteredLocation = location;
    pushSimple(() => _createLanguagesPage(), _PAGE_LANGUAGES);
  }

@override
  void onLanguagesSelected(List<LanguageModel> languages) {
    final repo = UserRepository.get();
    final user = repo.createNewUser(_selectedHobbies, _enteredLocation, languages);
    _listener().onProfileSetupComplete(user);
  }

ProfileSetupFlowListener _listener() {
    return context.findAncestorStateOfType<ProfileSetupFlowListener>();
  }
}