Await future for a specific time

How would you wait for future response for a specific amount of time?

Say, we make a http post request and await for its response before we close the http request, but, we wait for only 3 secs, else we close the request.

How would you achieve that?

Something like

Future makePostReq() async{
....

await http response for 3 secs

....

if(response) {
... Do something with it
}

Http.close

}

### Future.any([*asyncfunc*, ...])

Here's an example of using Remi's `Future.any` solution where the future that returns first, will be used. The other is discarded.

So, the first future is your data-gathering/slow function and the other is a fallback when your call is taking too long.
```
dynamic result = await Future.any([
getData(fakeDelay: seconds), // ← hope this returns first
timeoutAfter(sec: timeout, onTimeout: () => 'Timed Out!', ) // ← waited too long, do this
]);
```


### Example in Flutter Page

Here's a copy/paste example for a Flutter page:

(look at your debug/run output window for messages)
```
import 'package:flutter/material.dart';

class FutureTimeoutPage extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('Future or Timeout Page'),
),
body: FutureAnyExample(),
);
}
}

class FutureAnyExample extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text('Complete before timeout or timeout:'),
SizedBox(height: 30,),
Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
ElevatedButton(onPressed: () => getDataOrTimeout(seconds: 1, timeout: 3),
child: Text('In Time')),
ElevatedButton(onPressed: () => getDataOrTimeout(seconds: 5, timeout: 3),
child: Text('Too Slow'))
],
)
],
);
}

Future<void> getDataOrTimeout({int seconds, int timeout}) async {
/// In Future.any, put as many async functions as you need.
/// Whichever completes first, will be returned. All others are discarded
dynamic result = await Future.any([
getData(fakeDelay: seconds), // ← hope this returns first
timeoutAfter(sec: timeout, onTimeout: () => 'Timed Out!', ) // ← waited too long, do this
]);

print(result);
}

/// Mock of a long-running operation like getting DB data, or API call
Future<String> getData({int fakeDelay}) async {
return Future.delayed(Duration(seconds: fakeDelay), () => 'Data returned!');
}

/// Do this in case my long-running op takes too long
/// Can run a function or just return some message
Future<dynamic> timeoutAfter({int sec, Function() onTimeout}) async {
return Future.delayed(Duration(seconds: sec), onTimeout);
}
}
```

You can do it very easily

try {
var response = await Http.get("YourUrl").timeout(const Duration(seconds: 3));
if(response.statusCode == 200){
print("Success");
}else{
print("Something wrong");
}
} on TimeoutException catch (e) {
print('Timeout');
} on Error catch (e) {
print('Error: $e');
}
This example sets timeout to 3 second. If it has been 3 seconds and no response received, it will throw `TimeoutException`

Import this :

import 'package:http/http.dart' as Http;
import 'dart:async';

You can use `Future.any` constructor to make a race condition

final result = await Future.any([
Future.value(42),
Future.delayed(const Duration(seconds: 3))
]);


You can also use [`Future.timeout`](

[To see links please register here]

) method


final result = await Future.value(42).timeout(const Duration(seconds: 3));