Google Sign In

https://pub.dev/packages/google_sign_in
Admin
A Flutter plugin for Google Sign-In, a secure authentication system for signing in with a Google...
Tokens:7,185
Snippets:85
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run Flutter Web on a Specific Port

Source: https://pub.dev/packages/google_sign_in_web

Use this command to start the development server on a fixed port, which is required for OAuth redirect URI consistency.

```bash
flutter run -d chrome --web-hostname localhost --web-port 7357
```

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

### Initialize Google Sign-In

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

Sets up the GoogleSignIn instance and triggers lightweight authentication.

```dart
final GoogleSignIn signIn = GoogleSignIn.instance;
    unawaited(
      signIn.initialize(clientId: clientId, serverClientId: serverClientId).then((
        _,
      ) {
        signIn.authenticationEvents
            .listen(_handleAuthenticationEvent)
            .onError(_handleAuthenticationError);

        /// This example always uses the stream-based approach to determining
        /// which UI state to show, rather than using the future returned here,
        /// if any, to conditionally skip directly to the signed-in state.
        signIn.attemptLightweightAuthentication();
      }),
    );
```

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

### Google Sign-In Implementation in Flutter

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

Demonstrates initializing the Google Sign-In platform, performing lightweight authentication, and requesting authorization for specific scopes.

```dart
// Copyright 2013 The Flutter Authors
// 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, avoid_print

import 'dart:async';
import 'dart:convert' show json;

import 'package:flutter/material.dart';
import 'package:google_sign_in_platform_interface/google_sign_in_platform_interface.dart';
import 'package:http/http.dart' as http;

const List<String> _scopes = <String>['https://www.googleapis.com/auth/contacts.readonly'];

void main() {
  runApp(const MaterialApp(title: 'Google Sign In', home: SignInDemo()));
}

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

  @override
  State createState() => SignInDemoState();
}

class SignInDemoState extends State<SignInDemo> {
  GoogleSignInUserData? _currentUser;
  bool _isAuthorized = false;
  String _contactText = '';
  String _errorMessage = '';
  // Future that completes when `init` has completed on the sign in instance.
  Future<void>? _initialization;

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

  Future<void> _ensureInitialized() {
    // The example app uses the parsing of values from google-services.json
    // to provide the serverClientId, otherwise it would be required here.
    return _initialization ??= GoogleSignInPlatform.instance.init(const InitParameters())
      ..catchError((dynamic _) {
        _initialization = null;
      });
  }

  void _setUser(GoogleSignInUserData? user) {
    setState(() {
      _currentUser = user;
    });
    if (user != null) {
      // Try getting contacts, in case authorization is already granted.
      _handleGetContact(user);
    }
  }

  Future<void> _signIn() async {
    await _ensureInitialized();
    try {
      final AuthenticationResults? result = await GoogleSignInPlatform.instance
          .attemptLightweightAuthentication(const AttemptLightweightAuthenticationParameters());
      _setUser(result?.user);
    } on GoogleSignInException catch (e) {
      setState(() {
        _errorMessage = e.code == GoogleSignInExceptionCode.canceled
            ? ''
            : 'GoogleSignInException ${e.code}: ${e.description}';
      });
    }
  }

  Future<void> _handleAuthorizeScopes(GoogleSignInUserData user) async {
    try {
      final ClientAuthorizationTokenData? tokens = await GoogleSignInPlatform.instance
          .clientAuthorizationTokensForScopes(
            ClientAuthorizationTokensForScopesParameters(
              request: AuthorizationRequestDetails(
                scopes: _scopes,
                userId: user.id,
                email: user.email,
                promptIfUnauthorized: true,
              ),
            ),
          );

      setState(() {
        _isAuthorized = tokens != null;
        _errorMessage = '';
      });
      if (_isAuthorized) {
        unawaited(_handleGetContact(user));
      }
    } on GoogleSignInException catch (e) {
      setState(() {
        _errorMessage = 'GoogleSignInException ${e.code}: ${e.description}';
      });
    }
  }

  Future<Map<String, String>?> _getAuthHeaders(GoogleSignInUserData user) async {
    final ClientAuthorizationTokenData? tokens = await GoogleSignInPlatform.instance
        .clientAuthorizationTokensForScopes(
          ClientAuthorizationTokensForScopesParameters(
            request: AuthorizationRequestDetails(
              scopes: _scopes,
              userId: user.id,
              email: user.email,
              promptIfUnauthorized: false,
            ),
          ),
        );
    if (tokens == null) {
      return null;
    }

    return <String, String>{
      'Authorization': 'Bearer ${tokens.accessToken}',
      // TODO(kevmoo): Use the correct value once it's available.
      // See https://github.com/flutter/flutter/issues/80905
      'X-Goog-AuthUser': '0',
    };
  }
```

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

### Basic Flutter App Entry Point

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

A minimal Flutter application structure used for testing the plugin. Check the console output for runtime results.

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

import 'package:flutter/material.dart';

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

/// App for testing
class MyApp extends StatefulWidget {
  /// Default Constructor
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  @override
  Widget build(BuildContext context) {
    return const Text('Testing... Look at the console output for results!');
  }
}
```

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

### Configure URL Schemes in Info.plist

Source: https://pub.dev/packages/google_sign_in_ios

Add the CFBundleURLTypes configuration to handle the Google Sign-in redirect URI.

```xml
<!-- Put me in the [my_project]/ios/Runner/Info.plist file -->
<!-- Google Sign-in Section -->
<key>CFBundleURLTypes</key>
<array>
	<dict>
		<key>CFBundleTypeRole</key>
		<string>Editor</string>
		<key>CFBundleURLSchemes</key>
		<array>
			<!-- TODO Replace this value: -->
			<!-- Copied from GoogleService-Info.plist key REVERSED_CLIENT_ID -->
			<string>com.googleusercontent.apps.861823949799-vc35cprkp249096uujjn0vvnmcvjppkn</string>
		</array>
	</dict>
</array>
<!-- End of the Google Sign-in Section -->
```

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

### Build Google Sign-In UI

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

Constructs the UI components for sign-in, sign-out, and permission management based on the user's authentication state.

```dart
Widget _buildBody() {
    final GoogleSignInUserData? user = _currentUser;
    return Column(
      mainAxisAlignment: MainAxisAlignment.spaceAround,
      children: <Widget>[
        if (user != null) ...<Widget>[
          ListTile(title: Text(user.displayName ?? ''), subtitle: Text(user.email)),
          const Text('Signed in successfully.'),
          ElevatedButton(onPressed: _handleSignOut, child: const Text('SIGN OUT')),
          if (_isAuthorized) ...<Widget>[
            // The user has Authorized all required scopes.
            if (_contactText.isNotEmpty) Text(_contactText),
            ElevatedButton(child: const Text('REFRESH'), onPressed: () => _handleGetContact(user)),
          ] else ...<Widget>[
            // The user has NOT Authorized all required scopes.
            const Text('Authorization needed to read your contacts.'),
            ElevatedButton(
              onPressed: () => _handleAuthorizeScopes(user),
              child: const Text('REQUEST PERMISSIONS'),
            ),
          ],
        ] else ...<Widget>[
          const Text('You are not currently signed in.'),
          ElevatedButton(onPressed: _handleSignIn, child: const Text('SIGN IN')),
        ],
        if (_errorMessage.isNotEmpty) Text(_errorMessage),
      ],
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Google Sign In')),
      body: ConstrainedBox(constraints: const BoxConstraints.expand(), child: _buildBody()),
    );
  }
```

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

### Initialize GoogleSignIn and handle authentication events

Source: https://pub.dev/packages/google_sign_in

Initializes the GoogleSignIn instance and sets up listeners for authentication events. Uses a stream-based approach to manage UI state.

```dart
final GoogleSignIn signIn = GoogleSignIn.instance;
unawaited(
  signIn.initialize(clientId: clientId, serverClientId: serverClientId).then((
    _,
  ) {
    signIn.authenticationEvents
        .listen(_handleAuthenticationEvent)
        .onError(_handleAuthenticationError);

    /// This example always uses the stream-based approach to determining
    /// which UI state to show, rather than using the future returned here,
    /// if any, to conditionally skip directly to the signed-in state.
    signIn.attemptLightweightAuthentication();
  }),
);
```

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

### Implement sign-in flow with platform-specific fallbacks

Source: https://pub.dev/packages/google_sign_in

Uses authenticate() where supported, otherwise falls back to platform-specific UI components like web-rendered buttons.

```dart
if (GoogleSignIn.instance.supportsAuthenticate())
  ElevatedButton(
    onPressed: () async {
      try {
        await GoogleSignIn.instance.authenticate();
      } catch (e) {
        // ···
      }
    },
    child: const Text('SIGN IN'),
  )
else ...<Widget>[
  if (kIsWeb)
    web.renderButton()
  // ···
],
```

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

### Initialize Google Sign-In in Dart

Source: https://pub.dev/packages/google_sign_in_ios

Use the GoogleSignInPlatform instance to initialize authentication parameters programmatically as an alternative to Info.plist configuration.

```dart
final GoogleSignInPlatform signIn = GoogleSignInPlatform.instance;
await signIn.init(
  const InitParameters(
    // The OAuth client ID of your app. This is required.
    clientId: 'Your Client ID',
    // If you need to authenticate to a backend server, specify the server's
    // OAuth client ID. This is optional.
    serverClientId: 'Your Server ID',
  ),
);
```

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

### Build Authentication UI Components

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

Constructs the main body of the sign-in page, switching between authenticated and unauthenticated views based on the current user state.

```dart
Widget _buildBody() {
    final GoogleSignInAccount? user = _currentUser;
    return Column(
      mainAxisAlignment: MainAxisAlignment.spaceAround,
      children: <Widget>[
        if (user != null)
          ..._buildAuthenticatedWidgets(user)
        else
          ..._buildUnauthenticatedWidgets(),
        if (_errorMessage.isNotEmpty) Text(_errorMessage),
      ],
    );
  }
```

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

### Add dependency via command line

Source: https://pub.dev/packages/google_sign_in_web/install

Use this command in your terminal to automatically add the package to your project.

```bash
$ flutter pub add google_sign_in_web
```

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

### Build Authenticated User Widgets

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

Generates the UI for signed-in users, including profile information, scope authorization controls, and sign-out functionality.

```dart
List<Widget> _buildAuthenticatedWidgets(GoogleSignInAccount user) {
    return <Widget>[
      // The user is Authenticated.
      ListTile(
        leading: GoogleUserCircleAvatar(identity: user),
        title: Text(user.displayName ?? ''),
        subtitle: Text(user.email),
      ),
      const Text('Signed in successfully.'),
      if (_isAuthorized) ...<Widget>[
        // The user has Authorized all required scopes.
        if (_contactText.isNotEmpty) Text(_contactText),
        ElevatedButton(
          child: const Text('REFRESH'),
          onPressed: () => _handleGetContact(user),
        ),
        if (_serverAuthCode.isEmpty)
          ElevatedButton(
            child: const Text('REQUEST SERVER CODE'),
            onPressed: () => _handleGetAuthCode(user),
          )
        else
          Text('Server auth code:\n$_serverAuthCode'),
      ] else ...<Widget>[
        // The user has NOT Authorized all required scopes.
        const Text('Authorization needed to read your contacts.'),
        ElevatedButton(
          onPressed: () => _handleAuthorizeScopes(user),
          child: const Text('REQUEST PERMISSIONS'),
        ),
      ],
      ElevatedButton(onPressed: _handleSignOut, child: const Text('SIGN OUT')),
    ];
  }
```

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

### Configure Google Sign-In Client ID

Source: https://pub.dev/packages/google_sign_in_web

Add the OAuth client ID meta tag to the head section of your web/index.html file.

```html
<meta name="google-signin-client_id" content="YOUR_GOOGLE_SIGN_IN_OAUTH_CLIENT_ID.apps.googleusercontent.com">
```

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

### Handle Google Sign-In Authentication

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

Authenticates the user using GoogleSignInPlatform and handles potential exceptions.

```dart
Future<void> _handleSignIn() async {
    try {
      await _ensureInitialized();
      final AuthenticationResults result = await GoogleSignInPlatform.instance.authenticate(
        const AuthenticateParameters(),
      );
      _setUser(result.user);
    } on GoogleSignInException catch (e) {
      setState(() {
        _errorMessage = e.code == GoogleSignInExceptionCode.canceled
            ? ''
            : 'GoogleSignInException ${e.code}: ${e.description}';
      });
    }
  }
```

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

### Configure Server Client ID in Info.plist

Source: https://pub.dev/packages/google_sign_in_ios

Include the GIDServerClientID key if your application requires backend server authentication.

```xml
<key>GIDServerClientID</key>
<string>[YOUR SERVER CLIENT ID]</string>
```

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

### Import the package

Source: https://pub.dev/packages/google_sign_in_platform_interface/install

Include this import statement in your Dart files to access the platform interface classes.

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

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

### Configure macOS Keychain Entitlements

Source: https://pub.dev/packages/google_sign_in_ios

Add the required keychain-access-groups entitlement to your macOS project to prevent PlatformException errors during sign-in.

```xml
    <key>keychain-access-groups</key>
    <array>
        <string>$(AppIdentifierPrefix)com.google.GIDSignIn</string>
    </array>
```

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

### Import the library

Source: https://pub.dev/packages/google_sign_in_web/install

Include this import statement in your Dart files to access the package functionality.

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

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

### Configure Maven Repository for Android

Source: https://pub.dev/packages/google_sign_in/changelog

Add the Google Maven repository to the android/build.gradle file to resolve dependencies.

```gradle
allprojects {
    repositories {
        jcenter()
        maven {                              // NEW
            url "https://maven.google.com"   // NEW
        }                                    // NEW
    }
}
```

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

### Handle Google Sign-In and Sign-Out

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

Methods to authenticate the user and disconnect the current session using the GoogleSignInPlatform interface.

```dart
Future<void> _handleSignIn() async {
    try {
      await _ensureInitialized();
      final AuthenticationResults result = await GoogleSignInPlatform.instance.authenticate(
        const AuthenticateParameters(),
      );
      _setUser(result.user);
    } on GoogleSignInException catch (e) {
      setState(() {
        _errorMessage = e.code == GoogleSignInExceptionCode.canceled
            ? ''
            : 'GoogleSignInException ${e.code}: ${e.description}';
      });
    }
  }

  Future<void> _handleSignOut() async {
    await _ensureInitialized();
    await GoogleSignInPlatform.instance.disconnect(const DisconnectParams());
  }
```

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

### Configure iOS Client ID in Info.plist

Source: https://pub.dev/packages/google_sign_in_ios

Add the GIDClientID key to your Info.plist using the client ID from your GoogleService-Info.plist.

```xml
<key>GIDClientID</key>
<!-- TODO Replace this value: -->
<!-- Copied from GoogleService-Info.plist key CLIENT_ID -->
<string>[YOUR IOS CLIENT ID]</string>
```

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

### Handle Sign-In Exceptions

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

Maps GoogleSignInException codes to user-friendly error messages.

```dart
String _errorMessageFromSignInException(GoogleSignInException e) {
    // In practice, an application should likely have specific handling for most
    // or all of the, but for simplicity this just handles cancel, and reports
    // the rest as generic errors.
    return switch (e.code) {
      GoogleSignInExceptionCode.canceled => 'Sign in canceled',
      _ => 'GoogleSignInException ${e.code}: ${e.description}',
    };
  }
```

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

### Scaffold Main Application View

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

Defines the primary Scaffold structure for the Google Sign-In page.

```dart
@override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Google Sign In')),
      body: ConstrainedBox(
        constraints: const BoxConstraints.expand(),
        child: _buildBody(),
      ),
    );
  }
```

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

### Build Unauthenticated User Widgets

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

Displays sign-in options for users who are not currently authenticated, including platform-specific authentication methods.

```dart
List<Widget> _buildUnauthenticatedWidgets() {
    return <Widget>[
      const Text('You are not currently signed in.'),
      // #docregion ExplicitSignIn
      if (GoogleSignIn.instance.supportsAuthenticate())
        ElevatedButton(
          onPressed: () async {
            try {
              await GoogleSignIn.instance.authenticate();
            } catch (e) {
              // #enddocregion ExplicitSignIn
              _errorMessage = e.toString();
              // #docregion ExplicitSignIn
            }
          },
          child: const Text('SIGN IN'),
        )
      else ...<Widget>[
        if (kIsWeb)
          web.renderButton()
        // #enddocregion ExplicitSignIn
        else
          const Text(
            'This platform does not have a known authentication method',
          ),
        // #docregion ExplicitSignIn
      ],
      // #enddocregion ExplicitSignIn
    ];
  }
```

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

### Add dependency via Flutter CLI

Source: https://pub.dev/packages/google_sign_in_android/install

Use the Flutter CLI to automatically add the package to your project dependencies.

```bash
 $ flutter pub add google_sign_in_android
```

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

### Request a server auth code

Source: https://pub.dev/packages/google_sign_in

Obtain an authorization code for backend server access. Must be triggered by user interaction on platforms where authorizationRequiresUserInteraction returns true.

```dart
final GoogleSignInServerAuthorization? serverAuth = await user
    .authorizationClient
    .authorizeServer(scopes);
```

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

### Handle Google Sign-Out

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

Disconnects the current user session using the platform interface.

```dart
Future<void> _handleSignOut() async {
    await _ensureInitialized();
    await GoogleSignInPlatform.instance.disconnect(const DisconnectParams());
  }
```

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

### Add dependency to pubspec.yaml

Source: https://pub.dev/packages/google_sign_in_web/install

Manually add this line to the dependencies section of your pubspec.yaml file.

```yaml
dependencies:
  google_sign_in_web: ^1.1.3
```

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

### Define OAuth Scopes

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

Defines the list of Google API scopes required by the application.

```dart
const List<String> scopes = <String>[
  'https://www.googleapis.com/auth/contacts.readonly',
];
```

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

### Authorize Additional Scopes

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

Prompts the user to authorize specific scopes. This should be triggered by a user interaction.

```dart
final GoogleSignInClientAuthorization authorization = await user
          .authorizationClient
          .authorizeScopes(scopes);
```

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

### Check Authorization for Scopes

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

Retrieves the current user and checks if they have granted the necessary permissions for specific scopes.

```dart
final GoogleSignInAccount? user = // ...
    
    // Check for existing authorization.
    final GoogleSignInClientAuthorization? authorization = await user
        ?.authorizationClient
        .authorizationForScopes(scopes);
```

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

### Request Server Authorization Code

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

Obtains a server authorization code for the requested scopes.

```dart
final GoogleSignInServerAuthorization? serverAuth = await user
          .authorizationClient
          .authorizeServer(scopes);
```

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

### Retrieve Contact Information via People API

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

Fetches contact data for a signed-in user by constructing authorization headers and querying the People API REST endpoint.

```dart
Future<void> _handleGetContact(GoogleSignInAccount user) async {
    setState(() {
      _contactText = 'Loading contact info...';
    });
    final Map<String, String>? headers = await user.authorizationClient
        .authorizationHeaders(scopes);
    if (headers == null) {
      setState(() {
        _contactText = '';
        _errorMessage = 'Failed to construct authorization headers.';
      });
      return;
    }
    final http.Response response = await http.get(
      Uri.parse(
        'https://people.googleapis.com/v1/people/me/connections'
        '?requestMask.includeField=person.names',
      ),
      headers: headers,
    );
    if (response.statusCode != 200) {
      if (response.statusCode == 401 || response.statusCode == 403) {
        setState(() {
          _isAuthorized = false;
          _errorMessage =
              'People API gave a ${response.statusCode} response. '
              'Please re-authorize access.';
        });
      } else {
        print('People API ${response.statusCode} response: ${response.body}');
        setState(() {
          _contactText =
              'People API gave a ${response.statusCode} '
              'response. Check logs for details.';
        });
      }
      return;
    }
    final Map<String, dynamic> data =
        json.decode(response.body) as Map<String, dynamic>;
    final String? namedContact = _pickFirstNamedContact(data);
    setState(() {
      if (namedContact != null) {
        _contactText = 'I see you know $namedContact!';
      } else {
        _contactText = 'No contacts to display.';
      }
    });
  }
```

```dart
String? _pickFirstNamedContact(Map<String, dynamic> data) {
    final List<dynamic>? connections = data['connections'] as List<dynamic>?;
    final Map<String, dynamic>? contact =
        connections?.firstWhere(
              (dynamic contact) =>
                  (contact as Map<Object?, dynamic>)['names'] != null,
              orElse: () => null,
            )
            as Map<String, dynamic>?;
    if (contact != null) {
      final List<dynamic> names = contact['names'] as List<dynamic>;
      final Map<String, dynamic>? name =
          names.firstWhere(
                (dynamic name) =>
                    (name as Map<Object?, dynamic>)['displayName'] != null,
                orElse: () => null,
              )
              as Map<String, dynamic>?;
      if (name != null) {
        return name['displayName'] as String?;
      }
    }
    return null;
  }
```

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

### Request additional scopes

Source: https://pub.dev/packages/google_sign_in

Initiate an authorization request when required scopes have not been granted. Must be triggered by user interaction on platforms where authorizationRequiresUserInteraction returns true.

```dart
final GoogleSignInClientAuthorization authorization = await user
    .authorizationClient
    .authorizeScopes(scopes);
```

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

### Fetch Google Contacts API Data

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

Retrieves contact information using authenticated headers. Requires a valid GoogleSignInUserData object.

```dart
Future<void> _handleGetContact(GoogleSignInUserData user) async {
    setState(() {
      _contactText = 'Loading contact info...';
    });
    final Map<String, String>? headers = await _getAuthHeaders(user);
    setState(() {
      _isAuthorized = headers != null;
    });
    if (headers == null) {
      return;
    }
    final http.Response response = await http.get(
      Uri.parse(
        'https://people.googleapis.com/v1/people/me/connections'
        '?requestMask.includeField=person.names',
      ),
      headers: headers,
    );
    if (response.statusCode != 200) {
      setState(() {
        _contactText =
            'People API gave a ${response.statusCode} '
            'response. Check logs for details.';
      });
      print('People API ${response.statusCode} response: ${response.body}');
      return;
    }
    final data = json.decode(response.body) as Map<String, dynamic>;
    final int contactCount = (data['connections'] as List<dynamic>?)?.length ?? 0;
    setState(() {
      _contactText = '$contactCount contacts found';
    });
  }
```

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

### Sign Out and Disconnect

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

Disconnects the current user session to reset the application state.

```dart
Future<void> _handleSignOut() async {
    // Disconnect instead of just signing out, to reset the example state as
    // much as possible.
    await GoogleSignIn.instance.disconnect();
  }
```

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

### Check for granted scopes

Source: https://pub.dev/packages/google_sign_in

Silently request an access token for previously authorized scopes.

```dart
const List<String> scopes = <String>[
  'https://www.googleapis.com/auth/contacts.readonly',
];
    final GoogleSignInAccount? user = // ...
    final GoogleSignInClientAuthorization? authorization = await user
        ?.authorizationClient
        .authorizationForScopes(scopes);
```
Tokens:
Raw