Added Type <T> & WhenError() handler (#1)

Added Type <T> & WhenError() handler

Author: sleeyax

.gitignore

@@ -9,3 +9,5 @@ build/
 
 # Directory created by dartdoc
 doc/api/
+
+**/ios/Flutter/flutter_export_environment.sh

example/android/gradle.properties

@@ -1,2 +1,3 @@
 org.gradle.jvmargs=-Xmx1536M
 
+android.enableR8=true

example/lib/main.dart

@@ -60,7 +60,8 @@ class _MyHomePageState extends State<MyHomePage> {
         future: widget._api.getRandomCat(),
         // this is where the magic happens
         rememberFutureResult: true,
-        whenDone: (dynamic cat) => _showCatWidget(cat),
+        whenDone: (Cat cat) => _showCatWidget(cat),
+        whenError: (Object error) => Text(error.toString()),
         whenNotDone: Center(child: Text('Loading...'))
       ),
       floatingActionButton: FloatingActionButton(

lib/src/enhanced_future_builder_base.dart

@@ -1,81 +1,101 @@
 import 'package:flutter/widgets.dart';
 
-class EnhancedFutureBuilder extends StatefulWidget {
+class EnhancedFutureBuilder<T> extends StatefulWidget {
   /// Future to resolve.
-  final Future future;
+  final Future<T> future;
+
   /// Whether or not the future result should be stored.
   final bool rememberFutureResult;
+
   /// Widget to display when connected to an asynchronous computation.
   final Widget whenActive;
+
   /// Widget to display when connected to an asynchronous computation and awaiting interaction.
   final Widget whenWaiting;
+
   /// Widget to display when not connected to n asynchronous computation.
   final Widget whenNone;
+
   /// Widget to display when the asynchronous computation is not done yet.
   final Widget whenNotDone;
+
   /// Function to call when the asynchronous computation is done.
-  final Widget Function(dynamic snapshotData) whenDone;
+  final Widget Function(T snapshotData) whenDone;
+
+  /// Function to call when the asynchronous computation is done with error.
+  /// If no function is passed, whenNotDone() will be used instead
+  final Widget Function(Object error) whenError;
+
   /// The data that will be used until a non-null [future] has completed.
   ///
   /// See [FutureBuilder] for more info
-  final dynamic initialData;
-
-  const EnhancedFutureBuilder({
-    Key key, 
-    @required this.future,
-    @required this.rememberFutureResult,
-    @required this.whenDone,
-    this.whenActive,
-    this.whenNotDone,
-    this.whenNone,
-    this.whenWaiting,
-    this.initialData
-  }) : 
-  assert(future != null),
-  assert(rememberFutureResult != null), 
-  assert(whenDone != null), 
-  super(key: key);
+  final T initialData;
+
+  const EnhancedFutureBuilder(
+      {Key key,
+      @required this.future,
+      @required this.rememberFutureResult,
+      @required this.whenDone,
+      @required this.whenNotDone,
+      this.whenError,
+      this.whenActive,
+      this.whenNone,
+      this.whenWaiting,
+      this.initialData})
+      : assert(future != null),
+        assert(rememberFutureResult != null),
+        assert(whenDone != null),
+        assert(whenNotDone != null),
+        super(key: key);
 
   @override
-  _EnhancedFutureBuilderState createState() => _EnhancedFutureBuilderState();
+  _EnhancedFutureBuilderState createState() => _EnhancedFutureBuilderState<T>();
 }
 
-class _EnhancedFutureBuilderState extends State<EnhancedFutureBuilder> {
-
-  Future _cachedFuture;
+class _EnhancedFutureBuilderState<T> extends State<EnhancedFutureBuilder<T>> {
+  Future<T> _cachedFuture;
 
-  @override 
+  @override
   void initState() {
     super.initState();
     _cachedFuture = this.widget.future;
   }
 
   @override
   Widget build(BuildContext context) {
-    return FutureBuilder(
-      future: this.widget.rememberFutureResult ? _cachedFuture : this.widget.future,
+    return FutureBuilder<T>(
+      future:
+          this.widget.rememberFutureResult ? _cachedFuture : this.widget.future,
       initialData: this.widget.initialData,
-      builder: (BuildContext context, snapshot) {
-        if (this.widget.whenActive != null && snapshot.connectionState == ConnectionState.active) {
+      builder: (context, snapshot) {
+        if (this.widget.whenActive != null &&
+            snapshot.connectionState == ConnectionState.active) {
           return this.widget.whenActive;
         }
-        
-        if (this.widget.whenNone != null && snapshot.connectionState == ConnectionState.none) {
+
+        if (this.widget.whenNone != null &&
+            snapshot.connectionState == ConnectionState.none) {
           return this.widget.whenNone;
         }
-        
-        if (this.widget.whenWaiting != null && snapshot.connectionState == ConnectionState.waiting) {
+
+        if (this.widget.whenWaiting != null &&
+            snapshot.connectionState == ConnectionState.waiting) {
           return this.widget.whenWaiting;
         }
 
         if (snapshot.connectionState == ConnectionState.done) {
+          if (snapshot.hasError) {
+            if (this.widget.whenError != null) {
+              return this.widget.whenError(snapshot.error);
+            } else {
+              return this.widget.whenNotDone;
+            }
+          }
           return this.widget.whenDone(snapshot.data);
         }
 
-        if (this.widget.whenNotDone != null && snapshot.connectionState != ConnectionState.done) {
-          return this.widget.whenNotDone;
-        }
+        return this.widget.whenNotDone;
       },
     );
   }
-}
+}