Explore Futures In Flutter

Shaiq khan
Aug 2 · 8 min read
Explore Futures In Flutter

Long-running errands or asynchronous activities are normal in portable applications. For instance, these tasks can be getting information over a network, keeping in touch with the database, perusing information from a document, and so forth

To perform such tasks in Flutter/Dart, we for the most part utilize a Future class and the keywords async and await. A Future class permits you to run work asynchronously to let loose whatever other threads ought not to be obstructed. Like the UI thread.

In this blog, we will Explore Futures In Flutter. We will see how to use the future in your flutter applications.

Table Of Contents ::

How to Using a Future

Error Handling

How to Managing Multiple Futures at Once

Timeouts

Conclusion

What is the Future?:

A Future addresses a computation that doesn’t finish right away. Though a typical function returns the outcome, an asynchronous function returns a Future, which will ultimately contain the outcome. The Future will reveal to you when the outcome is prepared.

So, a Future can be in one of three states:

  • > Uncompleted: The output is closed.
  • > Completed with value: The output is open, and data is ready.
  • > Completed with an error: The output is open, but something went wrong.

A Future is characterized precisely like a function in Dart, yet rather than Void, you utilize Future. If you need to return a value from Future, you pass it a Type.

Future myFutureAsVoid() {}
Future myFutureAsType() {}

Thus, in the accompanying code model, fetchUserOrder() returns a Future that finishes subsequent to printing to the console. Since it doesn’t return a usable value, fetchUserOrder() has the sort Future.

Future fetchUserOrder() {return Future.delayed(Duration(seconds: 2), () => 
print('DATA'));
}void main() {fetchUserOrder();print('Fetching user order..');}

As should be obvious, even though fetchUserOrder() executes before the print() call, the console will show the yield “Fetching user order “ before the yield from fetchUserOrder(): “DATA”. This is because fetchUserOrder() delays before it prints “DATA”.

How to Using a Future:

There are two different ways to execute a Future and utilize the value it returns. If it returns any whatsoever. The most well-known way is to await on the Future to return. For everything to fall into work, your function that is calling the code must be checked async.

Future getProductCostForUser() async {var user = await getUser();var order = await getOrder(user.uid);var product = await getProduct(order.productId);return product.totalCost;}main() async {var cost = await getProductCostForUser();print(cost);}

When an async function summons awaits, it is changed over into a Future and put into the execution line. At the point when the awaited Future is finished, the calling capacity is set apart as prepared for execution and it will be continued at some later point because the value of what was value is contained inside a Future object. The significant contrast is that no Threads should be stopped in this model.

In other words, async-await is only a decisive method of characterizing asynchronous functions and utilizing their outcomes into the future and it gives syntactic sugar that assists you with composing clean code including Futures. Here’s a memorable thing! If awaits will be utilized, we need to ensure that both the caller function and any capacities we call inside that function utilize the async modifier.

In some cases, you would prefer not to transform the function into a Future or imprint it async, so the alternate method to deal with a Future is by utilizing the .then function. It takes in a capacity that will be known as the value kind of your Future. It’s like a Promise in JavaScript without the determination, reject expresses.

void main() {Future.delayed(const Duration(seconds: 3),() => 100,).then((value) {print('The value is $value.'); // Prints later, after 3 seconds.});print('Waiting for a value...'); // Prints first.}

When we run the application, we ought to get the screen’s output like the underneath screen capture.

Waiting for a value... (3 seconds pass until callback executes)
The value is 100.

Error Handling:

Prospects have their own specific manner of taking care of handling errors. In the .then call and passing in your callback, you can likewise pass in a capacity to onError that will be called with the mistake got back from your Future.

FlatButton(
child: Text('Run My Future'),
onPressed: () {
runFuture();
},
)
// FutureFuture myFutureAsType() async {
await Future.delayed(Duration(seconds: 1));
return Future.error('Error from return!');
}
// Function to call futurevoid runFuture() {
myFutureAsType().then((value) {
// Run extra code here
}, onError: (error) {
print(error);
});
}

If you run the code above, you’ll see the ‘Error from return!’ message printed out following 1 second. If you need to expressly deal with and get errors from the Future, you can likewise utilize a devoted capacity called catchError.

void runFuture() {
myFutureAsType().then((value) {
// Run extra code here
})
.catchError( (error) {
print(error);
});
}

When dealing with a mistake in your Future you don’t have to consistently get back to the Future. error. All things considered, you can likewise throw an exception and it’ll show up at the same .catchError or onError callback.

Future myFutureAsType() async {
await Future.delayed(Duration(seconds: 1));
throw Exception('Error from Exception');
}

You can also mix await and .catchError. You can await a Future and use the .catchError call instead of wrapping it. This way, the value returned is null, but you can handle the error as well without wrapping it in try/catch.

You can likewise blend await and .catchError. You can await a Future and use the .catchError call as opposed to wrapping it. Along these lines, the value returned is invalid, yet you can deal with the blunder too without enveloping it by try/catch.

Future runMyFuture() async {
var value = await myFutureAsType()
.catchError((error) {
print(error);
});
}

How to Managing Multiple Futures at Once:

We should take a model where you have a screen where you can tap to download different things out of a list. You need to wait that this load of Futures will be finished before you proceed with your code. Future has a handy .wait call. This call permits you to give a list of Futures to it and it will run every one of them. At the point when the last one is finished, it will return context to your present Future.


FlatButton(
child: Text('Run Future'),
onPressed: () async {
await runMultipleFutures();
},
)
// Future to run
Future myFutureAsType(int id, int duration) async {
await Future.delayed(Duration(seconds: duration));
print('Delay complete for Future $id');
return true;
}
// Running multiple futures
Future runMultipleFutures() async { // Create list of multiple futures
var futures = List();
for(int i = 0; i < 5; i++) {
futures.add(myFutureAsType(i, Random(i).nextInt(5)));
}
await Future.wait(futures);// We're done with all futures execution
print('All the futures has completed');
}

If you tap the flat button above, we will start five Futures altogether and wait that every one of them will finish. You should see an outcome as the one shown underneath. It’s utilizing a random generator, so you’ll see various orders of the IDs.

I/flutter (12116): Delay complete for Future 2
I/flutter (12116): Delay complete for Future 3
I/flutter (12116): Delay complete for Future 0
I/flutter (12116): Delay complete for Future 4
I/flutter (12116): Delay complete for Future 1
I/flutter (12116): All the futures has completed

Timeouts:

In some cases, we don’t realize precisely how long a Future will run. It is a cycle that the client needs to unequivocally wait for, for example, there’s a loading indicator on the screen, so you presumably don’t need it to run for a really long time. On the off chance that you have something like this, you can break a Future utilizing the timeout call.

Future myFutureAsType(int id, int duration) async {
await Future.delayed(Duration(seconds: duration));
print('Delay complete for Future $id');
return true;
}
Future runTimeout() async {
await myFutureAsType(0, 10)
.timeout(Duration(seconds: 2), onTimeout: (){
print('0 timed out');
return false;
});
}

On the off chance that you run the code above, you’ll see 0 timed out and you’ll never see Delay total for Future 0. You can add extra rationale into the onTimeout callback.

Conclusion:

In the article, I have explained the basic structure of the Futures in a flutter; you can modify this code according to your choice. This was a small introduction to Futures On User Interaction from my side, and it’s working using Flutter.

I hope this blog will provide you with sufficient information on Trying up the Explore Futures in your flutter projects. We will show you What are the Future is?. It covers the fundamentals of what you’d need to deal with Futures in your code. There’s additionally the function .asStream that you can on utilizing a Future to return the outcomes into a stream. On the off chance that you have a codebase overwhelmed by streams, you can utilize this and consolidate it with your different streams effectively whenever required. So please try it.

❤ ❤ Thanks for reading this article ❤❤

If I got something wrong? Let me know in the comments. I would love to improve.

Clap 👏 If this article helps you.

Feel free to connect with us:
And read more articles from FlutterDevs.com.

FlutterDevs team of Flutter developers to build high-quality and functionally-rich apps. Hire a flutter developer for your cross-platform Flutter mobile app project on an hourly or full-time basis as per your requirement! You can connect with us on Facebook, GitHub, Twitter, and LinkedIn for any flutter-related queries.

We welcome feedback and hope that you share what you’re working on using #FlutterDevs. We truly enjoy seeing how you use Flutter to build beautiful, interactive web experiences.

FlutterDevs

FlutterDevs intent to deliver Flutter apps with high…