Connectivity Plus

https://pub.dev/packages/connectivity_plus
Admin
A Flutter plugin for discovering the state and types of network connectivity (WiFi, mobile/cellular,...
Tokens:10,002
Snippets:85
Trust Score:9.9
Update:6 hours ago
Show doc for...
Tokens:
Raw
### Example main.dart for connectivity_plus

Source: https://pub.dev/packages/connectivity_plus/example

Complete example app that initializes connectivity checking, listens to connectivity changes, and displays the current connection status. Uses Connectivity.checkConnectivity() and onConnectivityChanged stream. Handles PlatformException and widget unmounting.

```dart
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// ignore_for_file: public_member_api_docs

import 'dart:async';
import 'dart:developer' as developer;

import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

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

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        useMaterial3: true,
        colorSchemeSeed: const Color(0x9f4376f8),
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  List<ConnectivityResult> _connectionStatus = [ConnectivityResult.none];
  final Connectivity _connectivity = Connectivity();
  late StreamSubscription<List<ConnectivityResult>> _connectivitySubscription;

  @override
  void initState() {
    super.initState();
    initConnectivity();

    _connectivitySubscription =
        _connectivity.onConnectivityChanged.listen(_updateConnectionStatus);
  }

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

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> initConnectivity() async {
    late List<ConnectivityResult> result;
    // Platform messages may fail, so we use a try/catch PlatformException.
    try {
      result = await _connectivity.checkConnectivity();
    } on PlatformException catch (e) {
      developer.log('Couldn\'t check connectivity status', error: e);
      return;
    }

    // If the widget was removed from the tree while the asynchronous platform
    // message was in flight, we want to discard the reply rather than calling
    // setState to update our non-existent appearance.
    if (!mounted) {
      return Future.value(null);
    }

    return _updateConnectionStatus(result);
  }

  Future<void> _updateConnectionStatus(List<ConnectivityResult> result) async {
    setState(() {
      _connectionStatus = result;
    });
    // ignore: avoid_print
    print('Connectivity changed: $_connectionStatus');
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Connectivity Plus Example'),
        elevation: 4,
      ),
      body: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          const Spacer(flex: 2),
          Text(_connectionStatus.hasConnectivity
              ? 'Connectivity available'
              : 'No connectivity'),
          const Spacer(flex: 2),
          Text(
            'Active connection types:',
            style: Theme.of(context).textTheme.headlineMedium,
          ),
          const Spacer(),
          ListView(
            shrinkWrap: true,
            children: List.generate(
                _connectionStatus.length,
                (index) => Center(
                      child: Text(
                        _connectionStatus[index].toString(),
                        style: Theme.of(context).textTheme.headlineSmall,
                      ),
                    )),
          ),
          const Spacer(flex: 2),
        ],
      ),
    );
  }
}

```

--------------------------------

### Check current connectivity types with Connectivity().checkConnectivity()

Source: https://pub.dev/packages/connectivity_plus/versions/7.3.2

Use this snippet to check the currently available network connection types. It returns a list of ConnectivityResult values and uses the hasConnectivity property to determine if any network is available. The example includes conditions for each connectivity type (mobile, wifi, ethernet, vpn, bluetooth, satellite, other, none) with platform-specific notes for Android, iOS, and macOS.

```dart
import 'package:connectivity_plus/connectivity_plus.dart';

final List<ConnectivityResult> connectivityResult = await (Connectivity().checkConnectivity());

// Determines whether any active network connection exists.
if (connectivityResult.hasConnectivity) {
  // Connectivity available (regardless of the underlying transport).
}

// This condition is for demo purposes only to explain every connection type.
// Use conditions which work for your requirements.
if (connectivityResult.contains(ConnectivityResult.mobile)) {
  // Mobile network available.
} else if (connectivityResult.contains(ConnectivityResult.wifi)) {
  // Wi-fi is available.
  // Note for Android:
  // When both mobile and Wi-Fi are turned on system will return Wi-Fi only as active network type
} else if (connectivityResult.contains(ConnectivityResult.ethernet)) {
  // Ethernet connection available.
} else if (connectivityResult.contains(ConnectivityResult.vpn)) {
  // Vpn connection active.
  // Note for iOS and macOS:
  // There is no separate network interface type for [vpn].
  // It returns [other] on any device (also simulator)
} else if (connectivityResult.contains(ConnectivityResult.bluetooth)) {
  // Bluetooth connection available.
} else if (connectivityResult.contains(ConnectivityResult.satellite)) {
  // Carrier-provided satellite network available
} else if (connectivityResult.contains(ConnectivityResult.other)) {
  // Connected to a network which is not in the above mentioned networks.
} else if (connectivityResult.contains(ConnectivityResult.none)) {
  // No available network types
}
```

--------------------------------

### Listen to connectivity changes with Connectivity().onConnectivityChanged

Source: https://pub.dev/packages/connectivity_plus/versions/7.3.2

Use this snippet to subscribe to connectivity changes via the onConnectivityChanged stream. It shows a StatefulWidget that listens for changes and cancels the subscription in dispose() to avoid memory leaks. The stream emits only distinct values.

```dart
import 'package:connectivity_plus/connectivity_plus.dart';
import 'dart:async';

class MyWidget extends StatefulWidget {
  @override
  _MyWidgetState createState() => _MyWidgetState();
}

class _MyWidgetState extends State<MyWidget> {
  StreamSubscription<List<ConnectivityResult>>? subscription;

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

    subscription = Connectivity().onConnectivityChanged.listen((List<ConnectivityResult> result) {
      // Received changes in available connectivity types!
    });
  }

  // Be sure to cancel subscription after you are done
  @override
  void dispose() {
    subscription?.cancel();
    super.dispose();
  }
}
```
Tokens:
Raw