Internet Connection Checker Plus

A Flutter package to check your internet connection with subsecond response times, even on mobile networks!

This library provides functionality to monitor and verify internet connectivity by checking reachability to various URIs. It relies on the connectivity_plus package for listening to connectivity changes and the http package for making network requests.

Features

• ✅ Check internet connectivity status
• ✅ Listen to internet connectivity changes
• ✅ Customizable endpoints and success criteria
• ✅ Customizable connectivity check logic

Supported Platforms

Permissions

Android

Add the following permission to your AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />

macOS

Add the following to your macOS .entitlements files:

<key>com.apple.security.network.client</key>
<true/>

For more information, see the Flutter Networking Documentation.

Usage

Checking for internet connectivity (one-time)

The simplest way to check if you have internet access:

final bool isConnected = await InternetConnection().hasInternetAccess;
if (isConnected) {
  print('Connected!');
} else {
  print('No internet connection.');
}

Listening to internet connectivity changes

The InternetConnection class exposes a stream of InternetStatus updates, allowing you to react to changes in connectivity:

final subscription = InternetConnection().onStatusChange.listen(
  (InternetStatus status) {
    if (status == InternetStatus.connected) {
      // Internet is connected
    } else {
      // Internet is disconnected
    }
  },
);

@override
void dispose() {
subscription.cancel();
super.dispose();
}

Using custom endpoints (URIs)

You can specify your own endpoints to check for connectivity:

final connection = InternetConnection.createInstance(
  customCheckOptions: [
    InternetCheckOption(uri: Uri.parse('https://example.com')),
  ],
);
final isConnected = await connection.hasInternetAccess;

Using custom success criteria

You can define what counts as a successful response:

final connection = InternetConnection.createInstance(
  customCheckOptions: [
    InternetCheckOption(
      uri: Uri.parse('https://example.com'),
      responseStatusFn: (response) {
        return response.statusCode >= 69 && response.statusCode < 169;
      },
    ),
    InternetCheckOption(
      uri: Uri.parse('https://example2.com'),
      responseStatusFn: (response) => response.statusCode == 420,
    ),
  ],
);
final isConnected = await connection.hasInternetAccess;

Using a custom connectivity check method

For advanced use cases, you can completely customize how connectivity checks are performed by providing your own connectivity checker:

final connection = InternetConnection.createInstance(
  customConnectivityCheck: (option) async {
    // Example: Use the Dio http client
    try {
      final dio = Dio();
      final response = await dio.head(
        option.uri,
        options: Options(headers: option.headers, receiveTimeout: option.timeout, validateStatus: (_) => true),
      );

      return InternetCheckResult(
        option: option,
        isSuccess: response.statusCode == 200,
      );
    } catch (_) {
      return InternetCheckResult(option: option, isSuccess: false);
    }
  },
);

This customization gives you full control over the connectivity detection process, allowing you to:

• Implement platform-specific network detection
• Use alternate connectivity checking strategies
• Implement custom fallback mechanisms
• Add detailed logging or metrics for connectivity checks
• Integrate with other network monitoring tools

Pause and Resume on App Lifecycle Changes

For situation where you want to pause any network requests when the app goes into the background and resume them when the app comes back into the foreground (see issue #27):

class MyWidget extends StatefulWidget {
  const MyWidget({super.key});

  @override
  State<MyWidget> createState() => _MyWidgetState();
}

class _MyWidgetState extends State<MyWidget> {
  late final StreamSubscription<InternetStatus> _subscription;
  late final AppLifecycleListener _listener;

  @override
  void initState() {
    super.initState();
    _subscription = InternetConnection().onStatusChange.listen((status) {
      // Handle internet status changes
    });
    _listener = AppLifecycleListener(
      onResume: _subscription.resume,
      onHide: _subscription.pause,
      onPause: _subscription.pause,
    );
  }

  @override
  void dispose() {
    _subscription.cancel();
    _listener.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    // Build your widget
  }
}

8. Using enableStrictCheck

The enableStrictCheck option can be used to require that all checked URIs must respond successfully for the internet to be considered available. By default, only one successful response is required.

final connection = InternetConnection.createInstance(
  enableStrictCheck: true,
  customCheckOptions: [
    InternetCheckOption(uri: Uri.parse('https://example.com')),
    InternetCheckOption(uri: Uri.parse('https://example2.com')),
  ],
);

Built-in and Additional URIs

Default URIs

The following endpoints are checked by default:

More Tested URIs

The following URIs are tested and work well with the package:

If you liked the package, then please give it a Like 👍🏼 and Star ⭐

Credits

This package is a cloned and modified version of the internet_connection_checker package, which itself was based on data_connection_checker (now unmaintained).

The main goal of this package is to provide a more reliable and faster solution for checking internet connectivity in Flutter applications.