Checking Network Status in Flutter App

In today's interconnected world, network connectivity plays a vital role in the functionality of many applications. Whether you're building a mobile app, a web service, or a desktop application, it's crucial to have a reliable method for determining the availability of a network connection. In this blog post, we will explore how to use the `Future<bool>` data type in Dart to check for network connectivity.

Understanding the Code:

Let's begin by analyzing the code snippet provided:

Future<bool> hasNetwork() async {
  try {
    final result = await InternetAddress.lookup('google.com');
    return result.isNotEmpty && result[0].rawAddress.isNotEmpty;
  } on SocketException catch (_) {
    return false;
  }
}

The `hasNetwork` function is defined as a `Future<bool>` function, indicating that it will return a `bool` value in the future. The `async` keyword is used to enable asynchronous behavior within the function.

The function uses a `try-catch` block to handle potential exceptions that may occur during network connectivity checks. Inside the `try` block, it calls `InternetAddress.lookup('google.com')` to perform a DNS lookup for the provided domain name.

If the lookup is successful and returns a non-empty result, the function checks if the `rawAddress` property of the first `InternetAddress` object is also non-empty. If both conditions are met, it returns `true`, indicating that a network connection is available.

In case a `SocketException` is caught during the DNS lookup, the function returns `false` to indicate the absence of a network connection.

Using the `Future<bool>` Pattern:

Now that we understand the code, let's explore how to utilize the `hasNetwork` function and leverage the `Future<bool>` pattern in our applications.

1. Calling the `hasNetwork` function:

To check for network connectivity, we can call the `hasNetwork` function as follows:

bool isConnected = await hasNetwork();

By using the `await` keyword, we can wait for the completion of the `Future<bool>` returned by the `hasNetwork` function. The `isConnected` variable will contain the resulting boolean value.

2. Handling the Result:

Once we have the result, we can take appropriate actions based on the network connectivity status. For example:

if (isConnected) {
  // Perform network-dependent operations
} else {
  // Display an error message or switch to offline mode
}

By branching our code based on the `isConnected` value, we can handle scenarios where a network connection is available or unavailable.

In this blog post, we explored how to use the `Future<bool>` data type in Dart to determine network connectivity. By encapsulating network checks within a `Future` object, we can perform asynchronous operations without blocking the main execution thread. This approach enables us to build more responsive applications that gracefully handle network-related scenarios. Incorporating the `hasNetwork` function into your codebase will ensure that your application can adapt to varying network conditions, enhancing the overall user experience.

Sample Code:

import 'dart:io';
import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatefulWidget {
  @override
  // ignore: library_private_types_in_public_api
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  bool isConnected = false;

  @override
  void initState() {
    super.initState();
    checkNetworkStatus();
  }

  Future<void> checkNetworkStatus() async {
    bool connected = await hasNetwork();
    setState(() {
      isConnected = connected;
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData(
        primarySwatch: Colors.orange,
      ),
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Network Status'),
        ),
        body: Center(
          child: isConnected
              ? const Text(
                  'Network connection is available',
                  style: TextStyle(fontSize: 20),
                )
              : const Text(
                  'No network connection',
                  style: TextStyle(fontSize: 20),
                ),
        ),
      ),
    );
  }
}

Future<bool> hasNetwork() async {
  try {
    final result = await InternetAddress.lookup('google.com');
    return result.isNotEmpty && result[0].rawAddress.isNotEmpty;
  } on SocketException catch (_) {
    return false;
  }
}