How to build Google sign-in with Flutter

For our new friends:

Logto is an Auth0 alternative designed for modern apps and SaaS products. It offers both Cloud and Open-source services to help you quickly launch your identity and management (IAM) system. Enjoy authentication, authorization, and multi-tenant management all in one.

We recommend starting with a free development tenant on Logto Cloud. This allows you to explore all the features easily.

In this article, we will go through the steps to quickly build the Google sign-in experience (user authentication) with Flutter and Logto.

Prerequisites

A running Logto instance. Check out the introduction page to get started.
Basic knowledge of Flutter.
A usable Google account.

Create an application in Logto

Logto is based on OpenID Connect (OIDC) authentication and OAuth 2.0 authorization. It supports federated identity management across multiple applications, commonly called Single Sign-On (SSO).

To create your Native app application, simply follow these steps:

Open the Logto Console. In the "Get started" section, click the "View all" link to open the application frameworks list. Alternatively, you can navigate to Logto Console > Applications, and click the "Create application" button.
In the opening modal, click the "Native app" section or filter all the available "Native app" frameworks using the quick filter checkboxes on the left. Click the "Flutter" framework card to start creating your application.
Enter the application name, e.g., "Bookstore," and click "Create application".

🎉 Ta-da! You just created your first application in Logto. You'll see a congrats page which includes a detailed integration guide. Follow the guide to see what the experience will be in your application.

Integrate Flutter with Logto

tip:

The SDK package is available on pub.dev and Logto GitHub repository.
The sample project is built using Flutter material. You can find it on pub.dev.
This SDK is compatible with Flutter applications on iOS, Android, and Web platforms. Compatibility with other platforms has not been tested.

Installation

pub.dev
GitHub

You can install the logto_dart_sdk package directly using the pub package manager. Run the following command under your project root:

flutter pub add logto_dart_sdk

Or add the following to your pubspec.yaml file:

dependencies:
  logto_dart_sdk: ^3.0.0

Then run:

flutter pub get

If you prefer to fork your own version of the SDK, you can clone the repository directly from GitHub.

git clone https://github.com/logto-io/dart

Dependency and configurations

SDK version compatibility

Logto SDK version	Dart SDK version	Dart 3.0 compatible
< 2.0.0	>= 2.17.6 < 3.0.0	false
>= 2.0.0 < 3.0.0	>= 3.0.0	true
>= 3.0.0	>= 3.6.0	true

flutter_secure_storage set up

Under the hood, this SDK uses flutter_secure_storage to implement the cross-platform persistent secure token storage.

Keychain is used for iOS
AES encryption is used for Android.

Config Android version

Set the android:minSdkVersion to >= 18 in your project's android/app/build.gradle file.

build.gradle
  android {
      ...

      defaultConfig {
          ...
          minSdkVersion 18
          ...
      }
  }

Disable auto backup on Android

By default Android backups data on Google Drive. It can cause exception java.security.InvalidKeyException:Failed to unwrap key. To avoid this,

To disable auto backup, go to your app manifest file and set the android:allowBackup and android:fullBackupContent attributes to false.

AndroidManifest.xml
<manifest ... >
    ...
    <application
      android:allowBackup="false"
      android:fullBackupContent="false"
      ...
    >
        ...
    </application>
</manifest>

Exclude sharedprefs from FlutterSecureStorage.

If you need to keep the android:fullBackupContent for your app rather than disabling it, you can exclude the sharedprefs directory from the backup. See more details in the Android documentation.

In your AndroidManifest.xml file, add the android:fullBackupContent attribute to the <application> element, as shown in the following example. This attribute points to an XML file that contains backup rules.
AndroidManifest.xml
```
<application ...
  android:fullBackupContent="@xml/backup_rules">
</application>
```
Create an XML file called @xml/backup_rules in the res/xml/ directory. In this file, add rules with the <include> and <exclude> elements. The following sample backs up all shared preferences except device.xml:
@xml/backup_rules
```
<?xml version="1.0" encoding="utf-8"?>
<full-backup-content>
  <exclude domain="sharedpref" path="FlutterSecureStorage"/>
</full-backup-content>
```

Please check flutter_secure_storage for more details.

flutter_web_auth_2 set up

Behind the scenes, this SDK uses flutter_web_auth_2 to authenticate users with Logto. This package provides a simple way to authenticate users with Logto using the system webview or browser.

This plugin uses ASWebAuthenticationSession on iOS 12+ and macOS 10.15+, SFAuthenticationSession on iOS 11, Chrome Custom Tabs on Android and opens a new window on Web.

iOS: No additional setup required

Android: Register the callback url on Android

In order to capture the callback url from Logto's sign-in web page, you will need to register your sign-in redirectUri to your AndroidManifest.xml file.

AndroidManifest.xml
  <manifest>
    <application>
        <activity
          android:name="com.linusu.flutter_web_auth_2.CallbackActivity"
          android:exported="true">
          <intent-filter android:label="flutter_web_auth_2">
          <action android:name="android.intent.action.VIEW" />
          <category android:name="android.intent.category.DEFAULT" />
          <category android:name="android.intent.category.BROWSABLE" />
          <data android:scheme="YOUR_CALLBACK_URL_SCHEME_HERE" />
          </intent-filter>
        </activity>
    </application>
  </manifest>

Web browser: Create an endpoint to handle the callback URL

If you are using the web platform, you need to create an endpoint to handle the callback URL and send it back to the application using the postMessage API.

callback.html
<!doctype html>
<title>Authentication complete</title>
<p>Authentication is complete. If this does not happen automatically, please close the window.</p>
<script>
  function postAuthenticationMessage() {
    const message = {
      'flutter-web-auth-2': window.location.href,
    };

    if (window.opener) {
      window.opener.postMessage(message, window.location.origin);
      window.close();
    } else if (window.parent && window.parent !== window) {
      window.parent.postMessage(message, window.location.origin);
    } else {
      localStorage.setItem('flutter-web-auth-2', window.location.href);
      window.close();
    }
  }

  postAuthenticationMessage();
</script>

Please check the setup guide in the flutter_web_auth_2 package for more details.

Integration

Init LogtoClient

Import the logto_dart_sdk package and initialize the LogtoClient instance at the root of your application.

lib/main.dart
import 'package:logto_dart_sdk/logto_dart_sdk.dart';
import 'package:http/http.dart' as http;

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(const MyApp());
}

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

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      title: 'Flutter Demo',
      home: MyHomePage(title: 'Logto 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> {
  late LogtoClient logtoClient;

  void render() {
    // state change
  }

  // LogtoConfig
  final logtoConfig = const LogtoConfig(
    endpoint: "<your-logto-endpoint>",
    appId: "<your-app-id>"
  );

  void _init() {
    logtoClient = LogtoClient(
      config: logtoConfig,
      httpClient: http.Client(), // Optional http client
    );
    render();
  }

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

  // ...
}

Before we dive into the details, here's a quick overview of the end-user experience. The sign-in process can be simplified as follows:

Your app invokes the sign-in method.
The user is redirected to the Logto sign-in page. For native apps, the system browser is opened.
The user signs in and is redirected back to your app (configured as the redirect URI).

This authentication process follows the OpenID Connect (OIDC) protocol, and Logto enforces strict security measures to protect user sign-in.
If you have multiple apps, you can use the same identity provider (Logto). Once the user signs in to one app, Logto will automatically complete the sign-in process when the user accesses another app.

To learn more about the rationale and benefits of redirect-based sign-in, see Logto sign-in experience explained.

Before starting, you need to add a redirect URI in the Admin Console for your application.

Let's switch to the Application details page of Logto Console. Add a Redirect URI io.logto://callback and click "Save changes".

For iOS, the redirect URI scheme does not really matter since the ASWebAuthenticationSession class will listen to the redirect URI regardless of if it's registered.
For Android, the redirect URI scheme must be registered in the AndroidManifest.xml file.

After the redirect URI is configured, we add a sign-in button to your page, which will call logtoClient.signIn API to invoke the Logto sign-in flow:

lib/main.dart
class _MyHomePageState extends State<MyHomePage> {
  // ...
  final redirectUri = 'io.logto://callback';

  @override
  Widget build(BuildContext context) {
    // ...

    Widget signInButton = TextButton(
      onPressed: () async {
        await logtoClient.signIn(redirectUri);
        render();
      },
      child: const Text('Sign In'),
    );

    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            SelectableText('My Demo App'),
            signInButton,
          ],
        ),
      ),
    );
  }
}

Implement sign-out

Let's switch to the Application details page of Logto Console. Add a Post Sign-out Redirect URI io.logto://callback and click "Save changes".

Post Sign-out Redirect URI in Logto Console

Post Sign-outRedirect URI is an OAuth 2.0 concept which implies the location should redirect after signing out.

Now let's add a sign-out button on the main page so users can sign out from your application.

lib/main.dart
class _MyHomePageState extends State<MyHomePage> {
  // ...

  final postSignOutRedirectUri = 'io.logto//home';

  @override
  Widget build(BuildContext context) {
    // ...

    Widget signOutButton = TextButton(
      onPressed: () async {
        await logtoClient.signOut(postSignOutRedirectUri);
        render();
      },
      child: const Text('Sign Out'),
    );

    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            SelectableText('My Demo App'),
            signInButton,
            signOutButton,
          ],
        ),
      ),
    );
  }
}

Handle authentication status

Logto SDK provides an asynchronous method to check the authentication status. The method is logtoClient.isAuthenticated. The method returns a boolean value, true if the user is authenticated, otherwise false.

In the example we conditionally render the sign-in and sign-out buttons based on the authentication status. Now let's update the render method in our Widget to handle the state change:

lib/main.dart
class _MyHomePageState extends State<MyHomePage> {
  // ...
  bool? isAuthenticated = false;

  void render() {
    setState(() async {
      isAuthenticated = await logtoClient.isAuthenticated;
    });
  }

  @override
  Widget build(BuildContext context) {
    // ...

    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            SelectableText('My Demo App'),
            isAuthenticated == true ? signOutButton : signInButton,
          ],
        ),
      ),
    );
  }
}

Checkpoint: Test your application

Now, you can test your application:

Run your application, you will see the sign-in button.
Click the sign-in button, the SDK will init the sign-in process and redirect you to the Logto sign-in page.
After you signed in, you will be redirected back to your application and see the sign-out button.
Click the sign-out button to clear token storage and sign out.

Add Google connector

To enable quick sign-in and improve user conversion, connect with Flutter as an identity provider. The Logto social connector helps you establish this connection in minutes by allowing several parameter inputs.

To add a social connector, simply follow these steps:

Navigate to Console > Connectors > Social Connectors.
Click "Add social connector" and select "Google".
Follow the README guide and complete required fields and customize settings.

note:

If you are following the in-place Connector guide, you can skip the next section.

Set up Google OAuth app

Set up a project in the Google API Console

Visit the Google API Console and sign in with your Google account.
Click the Select a project button on the top menu bar, and click the New Project button to create a project.
In your newly created project, click the APIs & Services to enter the APIs & Services menu.

Configure and register your application

On the left APIs & Services menu, click the OAuth consent screen button.
Choose the User Type you want, and click the Create button. (Note: If you select External as your User Type, you will need to add test users later.)

Now you will be on the Edit app registration page.

Edit app registration

Follow the instructions to fill out the OAuth consent screen form.
Click SAVE AND CONTINUE to continue.

Config scopes

Click ADD OR REMOVE SCOPES and select ../auth/userinfo.email, ../auth/userinfo.profile and openid in the popup drawer, and click UPDATE to finish. It is recommended that you consider adding all the scopes you may use, otherwise some scopes you added in the configuration may not work.
Fill out the form as you need.
Click SAVE AND CONTINUE to continue.

Add test users (External user type only)

Click ADD USERS and add test users to allow these users to access your application while testing.
Click SAVE AND CONTINUE to continue.

Now you should have the Google OAuth 2.0 consent screen configured.

Obtain OAuth 2.0 credentials

On the left APIs & Services menu, click the Credentials button.
On the Credentials page, click the + CREATE CREDENTIALS button on the top menu bar, and select OAuth client ID.
On the Create OAuth client ID page, select Web application as the application type.
Fill out the basic information for your application.
Click + Add URI to add an authorized domain to the Authorized JavaScript origins section. This is the domain that your logto authorization page will be served from. In our case, this will be ${your_logto_origin}. e.g.https://logto.dev.
Click + Add URI in the **Authorized redirect URIs** section to set up the **Authorized redirect URIs**, which redirect the user to the application after logging in. In our case, this will be ${your_logto_endpoint}/callback/${connector_id}. e.g. https://logto.dev/callback/${connector_id}. The connector_id can be found on the top bar of the Logto Admin Console connector details page.
Click Create to finish and then you will get the Client ID and Client Secret.

Configure your connector

Fill out the clientId and clientSecret field with Client ID and Client Secret you've got from OAuth app detail pages mentioned in the previous section.

scope is a space-delimited list of scopes. If not provided, scope defaults to be openid profile email.

prompts is an array of strings that specifies the type of user interaction that is required. The string can be one of the following values:

none: The authorization server does not display any authentication or user consent screens; it will return an error if the user is not already authenticated and has not pre-configured consent for the requested scopes. You can use none to check for existing authentication and/or consent.
consent: The authorization server prompts the user for consent before returning information to the client.
select_account: The authorization server prompts the user to select a user account. This allows a user who has multiple accounts at the authorization server to select amongst the multiple accounts that they may have current sessions for.

Config types

Name	Type
clientId	string
clientSecret	string
scope	string
prompts	string[]

Enable Google One Tap

Google One Tap is a secure and easy way to let users sign in to your website or app with their Google account.

Once you have the Google connector set up, you'll see a card for Google One Tap in the connector details page. You can enable Google One Tap in your sign-up and sign-in pages by toggling the switch.

When you enable Google One Tap, you can configure the following options:

Auto-select credential if possible: Automatically sign in the user with the Google account if certain conditions are met.
Cancel the prompt if user click/tap outside: Close the Google One Tap prompt if the user clicks or taps outside the prompt. If disabled, the user must click the close button to dismiss the prompt.
Enable Upgraded One Tap UX on ITP browsers: Enable the upgraded Google One Tap user experience on Intelligent Tracking Prevention (ITP) browsers. Please refer to this page for more information.

note:

To enable Google One Tap in your website (beyond the Logto sign-in experience), this feature is under development. Please stay tuned for updates.

Save your configuration

Double check you have filled out necessary values in the Logto connector configuration area. Click "Save and Done" (or "Save changes") and the Google connector should be available now.

Once you create a social connector successfully, you can enable it as a "Continue with Google" button in Sign-in Experience.

Navigate to Console > Sign-in experience > Sign-up and sign-in.
(Optional) Choose "Not applicable" for sign-up identifier if you need social login only.
Add configured Google connector to the "Social sign-in" section.

Testing and Validation

Return to your Flutter app. You should now be able to sign in with Google. Enjoy!

Create an application in Logto​

Integrate Flutter with Logto​

Installation​

Dependency and configurations​

SDK version compatibility​

flutter_secure_storage set up​

Config Android version​

Disable auto backup on Android​

flutter_web_auth_2 set up​

Integration​

Init LogtoClient​

Implement sign-in​

Regarding redirect-based sign-in​

Implement sign-out​

Handle authentication status​

Checkpoint: Test your application​

Add Google connector​

Set up Google OAuth app​

Set up a project in the Google API Console​

Configure your consent screen​

Configure and register your application​

Edit app registration​

Config OAuth consent screen​

Config scopes​

Add test users (External user type only)​

Obtain OAuth 2.0 credentials​

Configure your connector​

Config types​

Enable Google One Tap​

Save your configuration​

Enable Google connector in Sign-in Experience​

Testing and Validation​

Further readings​