Recording selector: Use a nested navigator

The selector also makes use of the new work tile widget.

lib/selectors/recording.dart

@@ -1,34 +1,119 @@
 import 'package:flutter/material.dart';
+import 'package:musicus/widgets/person_text.dart';
 
 import '../backend.dart';
 import '../database.dart';
 import '../editors/recording.dart';
 import '../widgets/works_by_composer.dart';
+import '../widgets/work_tile.dart';
 import '../widgets/performance_row.dart';
 
-class RecordingsSelector extends StatefulWidget {
+class PersonList extends StatelessWidget {
-  @override
+  final void Function(int personId) onSelect;
-  _RecordingsSelectorState createState() => _RecordingsSelectorState();
-}
 
-class _RecordingsSelectorState extends State<RecordingsSelector> {
+  PersonList({
-  Person composer;
+    this.onSelect,
-  Work work;
+  });
 
   @override
   Widget build(BuildContext context) {
     final backend = Backend.of(context);
 
-    bool showBackButton;
+    return Column(
-    String titleText;
+      children: <Widget>[
-    Widget content;
+        Material(
+          elevation: 2.0,
+          child: ListTile(
+            title: Text('Composers'),
+          ),
+        ),
+        Expanded(
+          child: StreamBuilder<List<Person>>(
+            stream: backend.db.allPersons().watch(),
+            builder: (context, snapshot) {
+              if (snapshot.hasData) {
+                return ListView.builder(
+                  itemCount: snapshot.data.length,
+                  itemBuilder: (context, index) {
+                    final person = snapshot.data[index];
+                    return ListTile(
+                      title: Text('${person.lastName}, ${person.firstName}'),
+                      onTap: () => onSelect(person.id),
+                    );
+                  },
+                );
+              } else {
+                return Container();
+              }
+            },
+          ),
+        ),
+      ],
+    );
+  }
+}
 
-    if (composer != null) {
+class WorkList extends StatelessWidget {
-      showBackButton = true;
+  final int composerId;
-      if (work != null) {
+  final void Function(int workId) onSelect;
-        titleText = work.title;
+
-        content = StreamBuilder<List<Recording>>(
+  WorkList({
-          stream: backend.db.recordingsByWork(work.id).watch(),
+    this.composerId,
+    this.onSelect,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      children: <Widget>[
+        Material(
+          elevation: 2.0,
+          child: ListTile(
+            leading: IconButton(
+              icon: const Icon(Icons.arrow_back),
+              onPressed: () => Navigator.pop(context),
+            ),
+            title: PersonText(composerId),
+          ),
+        ),
+        Expanded(
+          child: WorksByComposer(
+            personId: composerId,
+            onTap: (selectedWork) => onSelect(selectedWork.id),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class RecordingList extends StatelessWidget {
+  final int workId;
+  final void Function(Recording recording) onSelect;
+
+  RecordingList({
+    this.workId,
+    this.onSelect,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final backend = Backend.of(context);
+    return Column(
+      children: <Widget>[
+        Material(
+          elevation: 2.0,
+          child: WorkTile(
+            leading: IconButton(
+              icon: const Icon(Icons.arrow_back),
+              onPressed: () => Navigator.pop(context),
+            ),
+            workId: workId,
+          ),
+        ),
+        Expanded(
+          child: StreamBuilder<List<Recording>>(
+            stream: backend.db.recordingsByWork(workId).watch(),
             builder: (context, snapshot) {
               if (snapshot.hasData) {
                 return ListView.builder(
@@ -54,9 +139,7 @@ class _RecordingsSelectorState extends State<RecordingsSelector> {
                           }
                         },
                       ),
-                    onTap: () {
+                      onTap: () => onSelect(recording),
-                      Navigator.pop(context, recording);
-                    },
                     );
                   },
                 );
@@ -64,45 +147,27 @@ class _RecordingsSelectorState extends State<RecordingsSelector> {
                 return Container();
               }
             },
-        );
+          ),
-      } else {
+        ),
-        titleText = '${composer.firstName} ${composer.lastName}';
+      ],
-        content = WorksByComposer(
-          personId: composer.id,
-          onTap: (selectedWork) {
-            setState(() {
-              work = selectedWork;
-            });
-          },
     );
   }
-    } else {
+}
-      showBackButton = false;
-      titleText = 'Composers';
 
-      content = StreamBuilder<List<Person>>(
+class RecordingsSelector extends StatefulWidget {
-        stream: backend.db.allPersons().watch(),
+  @override
-        builder: (context, snapshot) {
+  _RecordingsSelectorState createState() => _RecordingsSelectorState();
-          if (snapshot.hasData) {
-            return ListView.builder(
-              itemCount: snapshot.data.length,
-              itemBuilder: (context, index) {
-                final person = snapshot.data[index];
-                return ListTile(
-                  title: Text('${person.lastName}, ${person.firstName}'),
-                  onTap: () {
-                    setState(() {
-                      composer = person;
-                    });
-                  },
-                );
-              },
-            );
-          } else {
-            return Container();
 }
-        },
+
-      );
+class _RecordingsSelectorState extends State<RecordingsSelector> {
+  final nestedNavigator = GlobalKey<NavigatorState>();
+  
+  @override
+  Widget build(BuildContext context) {
+    // This exists to circumvent the nested navigator when selecting a
+    // recording.
+    void popUpperNavigator(Recording recording) {
+      Navigator.pop(context, recording);
     }
 
     return WillPopScope(
@@ -114,22 +179,31 @@ class _RecordingsSelectorState extends State<RecordingsSelector> {
           ),
           title: Text('Select recording'),
         ),
-        body: Column(
+        body: Navigator(
-          children: <Widget>[
+          key: nestedNavigator,
-            Material(
+          onGenerateRoute: (settings) => settings.name == '/'
-              elevation: 2.0,
+              ? MaterialPageRoute(
-              child: ListTile(
+                  builder: (context) => PersonList(
-                leading: IconButton(
+                    onSelect: (personId) => nestedNavigator.currentState.push(
-                  icon: const Icon(Icons.arrow_back),
+                      MaterialPageRoute(
-                  onPressed: showBackButton ? goBack : null,
+                        builder: (context) => WorkList(
-                ),
+                          composerId: personId,
-                title: Text(titleText),
+                          onSelect: (workId) =>
+                              nestedNavigator.currentState.push(
+                            MaterialPageRoute(
+                              builder: (context) => RecordingList(
+                                workId: workId,
+                                onSelect: (recording) => popUpperNavigator(recording),
                               ),
                             ),
-            Expanded(
-              child: content,
                           ),
-          ],
+                        ),
+                      ),
+                    ),
+                  ),
+                )
+              : null,
+          initialRoute: '/',
         ),
         floatingActionButton: FloatingActionButton(
           child: const Icon(Icons.add),
@@ -148,25 +222,7 @@ class _RecordingsSelectorState extends State<RecordingsSelector> {
           },
         ),
       ),
-      onWillPop: () => Future.value(goBack()),
+      onWillPop: () async => !(await nestedNavigator.currentState.maybePop()),
     );
   }
-
-  bool goBack() {
-    if (work != null) {
-      setState(() {
-        work = null;
-      });
-
-      return false;
-    } else if (composer != null) {
-      setState(() {
-        composer = null;
-      });
-
-      return false;
-    } else {
-      return true;
-    }
-  }
 }