Don't use 'BuildContext's across async gaps

Question

`Don't use 'BuildContext's across async gaps.Try rewriting the code to not reference the 'BuildContext'

The problem in the provided code revolves around handling asynchronous operations and the usage of BuildContext across async gaps in a Flutter application.

Async Gaps: The code contains asynchronous operations such as making HTTP requests using the http package. However, there are instances where the code tries to access the BuildContext within the async functions, which is generally discouraged as it can lead to potential issues and is considered bad practice.

Passing Context: The BuildContext is typically used to access various resources and widgets within the Flutter framework. However, passing BuildContext across async gaps can cause problems as the context might become invalid or not available when the async operation completes.

Error Handling: The code includes error handling using try-catch blocks to handle exceptions that may occur during async operations. However, the error handling mechanism should be reviewed to ensure proper handling and reporting of errors to the user.

Provider Usage: The code utilizes the Provider package to access the UserProvider and update user-related data. However, there might be opportunities to optimize how the provider is used, considering best practices and efficiency.

HTTP Requests: The code makes HTTP requests to a server API, including signing up and signing in users, as well as retrieving user data. The implementation of these requests and their associated endpoints should be reviewed to ensure correctness and adherence to the API's specifications.

SharedPreferences: The code uses SharedPreferences to store and retrieve the user's authentication token. The usage of SharedPreferences should be validated to ensure it correctly handles token storage and retrieval.

Overall, the problem involves reworking the code to avoid passing BuildContext across async gaps, revisiting error handling mechanisms, optimizing provider usage, and verifying the implementation of HTTP requests and the usage of SharedPreferences. `

class AuthService {
  // sign up user
  void signUpUser({
    required BuildContext context,
    required String email,
    required String password,
    required String name,
  }) async {
    try {
      User user = User(
        id: '',
        name: name,
        password: password,
        email: email,
        address: '',
        type: '',
        token: '',
        cart: [],
      );

      http.Response res = await http.post(
        Uri.parse('$uri/api/signup'),
        body: user.toJson(),
        headers: <String, String>{
          'Content-Type': 'application/json; charset=UTF-8',
        },
      );

      httpErrorHandle(
        response: res,
        context: context,
        onSuccess: () {
          showSnackBar(
            context,
            'Account created! Login with the same credentials!',
          );
        },
      );
    } catch (e) {
      showSnackBar(context, e.toString());
    }
  }

  // sign in user
  void signInUser({
    required BuildContext context,
    required String email,
    required String password,
  }) async {
    try {
      http.Response res = await http.post(
        Uri.parse('$uri/api/signin'),
        body: jsonEncode({
          'email': email,
          'password': password,
        }),
        headers: <String, String>{
          'Content-Type': 'application/json; charset=UTF-8',
        },
      );
      httpErrorHandle(
        response: res,
        context: context,
        onSuccess: () async {
          SharedPreferences prefs = await SharedPreferences.getInstance();
          Provider.of<UserProvider>(context, listen: false).setUser(res.body);
          await prefs.setString('x-auth-token', jsonDecode(res.body)['token']);

          Navigator.pushNamedAndRemoveUntil(
            context,
            BottomBar.routeName,
            (route) => false,
          );
        },
      );
    } catch (e) {
      showSnackBar(context, e.toString());
    }
  }

  // get user data
  void getUserData(
    BuildContext context,
  ) async {
    try {
      SharedPreferences prefs = await SharedPreferences.getInstance();
      String? token = prefs.getString('x-auth-token');

      if (token == null) {
        prefs.setString('x-auth-token', '');
      }

      var tokenRes = await http.post(
        Uri.parse('$uri/tokenIsValid'),
        headers: <String, String>{
          'Content-Type': 'application/json; charset=UTF-8',
          'x-auth-token': token!
        },
      );

      var response = jsonDecode(tokenRes.body);

      if (response == true) {
        http.Response userRes = await http.get(
          Uri.parse('$uri/'),
          headers: <String, String>{
            'Content-Type': 'application/json; charset=UTF-8',
            'x-auth-token': token
          },
        );

        var userProvider = Provider.of<UserProvider>(context, listen: false);
        userProvider.setUser(userRes.body);
      }
    } catch (e) {
      showSnackBar(context, e.toString());
    }
  }
}

In this updated code, I added a reference to navigatorKey.currentContext to obtain the current Build Context within the methods. navigator Key is assumed to be a global key associated with a Navigator widget.