Google Play release bots trigger exceptions all over

[jamilsaadeh97]

Description

Whenever I upload a release build for my apps, I get bombarded with exceptions logged in Crashlytics.
This only happens on the Android release build. On iOS nothing is reported.

Those are the exceptions and stack traces reported:

Exception 1 - Occurs the most (30+ events reported for each release)

Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Bad state: Too many elements
#00 (ListBase.singleWhere [list.dart:156]) (BuildId: xxx)
#01 (AuthCategory.getPlugin [amplify_auth_category.dart:47]) (BuildId: xxx)
#02 (AuthService.isLoggedIn [auth_service.dart:89]) (BuildId: xxx) 

The number 02 is my own class, the rest are Amplify's.
AuthService.isLoggedIn code:

  Future<bool> get isLoggedIn async {
    try {
      final session = await Amplify.Auth.getPlugin(
        AmplifyAuthCognito.pluginKey,
      ).fetchAuthSession();
      return session.isSignedIn;
    } on SignedOutException {
      return false;
    } on SessionExpiredException {
      return false;
    } on NetworkException {
      return true;
    } catch (error, stack) {
      ExceptionsController.log(error, stack);
      rethrow;
    }
  }

Exception 2 (~5 events each release)

Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: PluginError {
  "message": "Auth plugin has not been added to Amplify",
  "recoverySuggestion": "Add Auth plugin to Amplify and call configure before calling Auth related APIs"
}
#00 (AmplifyCategory.defaultPlugin [amplify_categories.dart:87]) (BuildId: xxx)
#01 (AuthCategory.fetchAuthSession.<anonymous closure> [amplify_auth_category.dart:985]) (BuildId: xxx)
#02 (_rootRun [zone.dart:1525]) (BuildId: xxx)
#03 (_rootRun [zone.dart:1516]) (BuildId: xxx)
#04 (_CustomZone.run [zone.dart:1422]) (BuildId: xxx)
#05 (_runZoned [zone.dart:2034]) (BuildId: xxx)
#06 (runZoned [zone.dart:1960]) (BuildId: xxx)
#07 (identifyCall [amplify_category_method.dart:145]) (BuildId: xxx)
#08 (AuthCategory.fetchAuthSession [amplify_auth_category.dart:983]) (BuildId: xxx)
#09 (CognitoIamAuthProvider.retrieve [cognito_iam_auth_provider.dart:25]) (BuildId: xxx)
#10 (AWSSigV4Signer.sign.<anonymous closure> [aws_signer.dart:108]) (BuildId: xxx)
#11 (_rootRun [zone.dart:1525]) (BuildId: xxx)
#12 (_rootRun [zone.dart:1516]) (BuildId: xxx)
#13 (_CustomZone.run [zone.dart:1422]) (BuildId: xxx)
#14 (_runZoned [zone.dart:2034]) (BuildId: xxx)
#15 (runZoned [zone.dart:1960]) (BuildId: xxx)
#16 (signZoned [zone.dart:10]) (BuildId: xxx)
#17 (AWSSigV4Signer.sign [aws_signer.dart:107]) (BuildId: xxx)
#18 (WithSigV4.intercept [with_sig_v4.dart:45]) (BuildId: xxx)
#19 (SmithyHttpRequest.transformRequest [http_request.dart:138]) (BuildId: xxx)
#20 (SmithyHttpRequest.send.<anonymous closure> [http_request.dart:189]) (BuildId: xxx)

Exception 3 (~5 events each release)

Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: PushNotificationException {
  "message": "Error occurred awaiting for device token.",
  "recoverySuggestion": "Review the underlying exception.",
  "underlyingException": "PlatformException(TOKEN_RECEIVED, java.util.concurrent.ExecutionException: java.io.IOException: TOO_MANY_REGISTRATIONS, null, null)"
}
#00 (AmplifyPushNotifications._registerDeviceWhenConfigure [amplify_push_notifications_impl.dart:349]) (BuildId: xxx )
#01 (AmplifyPushNotifications.configure [amplify_push_notifications_impl.dart:231]) (BuildId: xxx )
#02 (Future.wait.<anonymous closure> [future.dart:525]) (BuildId: xxx )
#03 (AmplifyClass._configurePlugins [amplify_class.dart:199]) (BuildId: xxx )
#04 (AmplifyClass.configure [amplify_class.dart:118]) (BuildId: xxx )
#05 (_InitializationState._configureAmplify [init_app.dart:90]) (BuildId: xxx )

The _InitializationState._configureAmplify function is the normal configure amplify function of the apps

Based on Crashlytics the devices where the exceptions were thrown are 70% OnePlus8Pro on Android 11 and 30% Google Pixel 6 Pro on Android 12.

This will become confusing if a real user has those exceptions because I won't be able to differentiate between the bots and the real users. Also the Google Play bots can be ran randomly at any day as part of Google's check policy so it won't be always on a release date.

Categories

• Analytics
• API (REST)
• API (GraphQL)
• Auth
• Authenticator
• DataStore
• Notifications (Push)
• Storage

Steps to Reproduce

1. Configure Amplify and Crashlytics (or other tools for reporting)
2. Release android app and wait for the Google bots to run.

Screenshots

No response

Platforms

• iOS
• Android
• Web
• macOS
• Windows
• Linux

Flutter Version

3.35.3

Amplify Flutter Version

2.6.5

Deployment Method

Amplify CLI (Gen 1)

Schema

[jamilsaadeh97]

I've built a minimal app:

Flutter code

import 'package:amplify_analytics_pinpoint/amplify_analytics_pinpoint.dart';
import 'package:amplify_api/amplify_api.dart';
import 'package:amplify_auth_cognito/amplify_auth_cognito.dart';
import 'package:amplify_flutter/amplify_flutter.dart';
import 'package:amplify_push_notifications_pinpoint/amplify_push_notifications_pinpoint.dart';
import 'package:flutter/foundation.dart';
import 'amplifyconfiguration.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_crashlytics/firebase_crashlytics.dart';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';

import 'firebase_options.dart';

@pragma("vm:entry-point")
void backgroundNotificationsHandler(PushNotificationMessage message){}

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

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

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

class _MyAppState extends State<MyApp> {
  @override
  void initState() {
    RendererBinding.instance.deferFirstFrame();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData.dark(),
      home: const InitApp(),
    );
  }
}

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

  @override
  State<InitApp> createState() => _InitAppState();
}

class _InitAppState extends State<InitApp> {
  late Future<void> _initApp;

  Future<void> _configureAmplify() async {
    final authPlugin = AmplifyAuthCognito();
    final apiPlugin = AmplifyAPI(
      options: APIPluginOptions(
        modelProvider: ModelProvider.instance,
        subscriptionOptions: const GraphQLSubscriptionOptions(
          retryOptions: RetryOptions(maxAttempts: 50),
        ),
      ),
    );
    final analyticsPlugin = AmplifyAnalyticsPinpoint();
    final notificationsPlugin = AmplifyPushNotificationsPinpoint()
      ..onNotificationReceivedInBackground(backgroundNotificationsHandler);
    try {
      await Amplify.addPlugins([
        authPlugin,
        apiPlugin,
        analyticsPlugin,
        notificationsPlugin,
      ]);

      await Amplify.configure(amplifyconfig);
    } on AmplifyAlreadyConfiguredException {
      safePrint(
        'Tried to reconfigure Amplify; this can occur when your app restarts on Android.',
      );
    } on Exception catch (e, st) {
      safePrint("Exception when configuring amplify: $e");
      FirebaseCrashlytics.instance.recordError(e, st, fatal: true);
      rethrow;
    }
  }

  Future<void> _configureFirebase() async {
    try {
      await Firebase.initializeApp(
        options: DefaultFirebaseOptions.currentPlatform,
      );
    } on Exception catch (e, st) {
      FirebaseCrashlytics.instance.recordError(e, st, fatal: true);
      rethrow;
    }

    if (kReleaseMode) {
      FlutterError.onError =
          FirebaseCrashlytics.instance.recordFlutterFatalError;
      PlatformDispatcher.instance.onError = (error, stack) {
        FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
        return true;
      };
    }
  }

  Future<void> _loadApp() async {
    await _configureFirebase();
    await _configureAmplify();
  }

  @override
  void initState() {
    super.initState();
    _initApp = _loadApp()
      ..whenComplete(RendererBinding.instance.allowFirstFrame);
  }

  @override
  Widget build(BuildContext context) {
    return FutureBuilder(
      future: _initApp,
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.done) {
          if (snapshot.hasError) {
            return Scaffold(
              body: Center(child: Text("Error: ${snapshot.error}")),
            );
          } else {
            return const InitialScreen();
          }
        } else {
          return const Scaffold(body: Center(child: Text("Loading...")));
        }
      },
    );
  }
}

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

  @override
  State<InitialScreen> createState() => _InitialScreenState();
}

class _InitialScreenState extends State<InitialScreen> {
  late final Future<bool> isLoggedInFuture;

  @override
  void initState() {
    super.initState();
    isLoggedInFuture = isLoggedIn();
  }
  @override
  Widget build(BuildContext context) {
    return FutureBuilder(future: isLoggedInFuture, builder: (context, snapshot) {
      if (snapshot.connectionState == ConnectionState.done) {
        if (snapshot.hasError) {
          return Scaffold(
            body: Center(child: Text("Error: ${snapshot.error}")),
          );
        } else {
          final isLoggedIn = snapshot.data ?? false;
          return Scaffold(
            body: Center(
              child: Text(isLoggedIn ? "Logged In" : "Not Logged In"),
            ),
          );
        }
      } else {
        return const Scaffold(body: Center(child: Text("Loading...")));
      }
    });
  }
}

Future<bool> isLoggedIn() async {
  try {
    final session = await Amplify.Auth.getPlugin(
      AmplifyAuthCognito.pluginKey,
    ).fetchAuthSession();
    final isLoggedIn = session.isSignedIn;
    return isLoggedIn;
  } on SignedOutException {
    return false;
  } on SessionExpiredException {
    return false;
  } on NetworkException {
    return true;
  } catch (error, stack) {
    FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
    rethrow;
  }
}

pubspec.yaml

name: bug
description: "A new Flutter project."
publish_to: 'none'
version: 1.0.0+1

environment:
  sdk: ^3.9.2

dependencies:
  flutter:
    sdk: flutter

  cupertino_icons: ^1.0.8
  amplify_flutter: ^2.0.0
  amplify_api: ^2.0.0
  amplify_auth_cognito: ^2.0.0
  amplify_push_notifications_pinpoint: ^2.0.0
  amplify_analytics_pinpoint: ^2.0.0

  firebase_core: ^4.0.0
  firebase_crashlytics: ^5.0.0


dev_dependencies:
  flutter_test:
    sdk: flutter

  flutter_lints: ^5.0.0
flutter:
  uses-material-design: true

[ekjotmultani]

Hi @jamilsaadeh97, thank you for providing the minimal app, I will take it and attempt reproduction

[ekjotmultani]

Is there a reason to not call _configureAmplify in main before runApp? It is possible Google Play Bots are triggering calls before Amplify is able to be configured, assuming your app is similar to the minimum reproduction you provided.

[jamilsaadeh97]

Honestly it's a personal preference. Over the years, I've grown to dislike initializing stuff in main because of the exceptions that might happen there (and when overlooked, it can freeze the splash screen which is a very bad UX).
When initialized like I sent above, it gives more control on what to show, how and when. Also it reports errors correctly.

It is possible Google Play Bots are triggering calls before Amplify is able to be configured, assuming your app is similar to the minimum reproduction you provided

I don't know how the bots can trigger calls since the whole app is protected by the FutureBuilder. It will only access the main screens (in the example, the InitialScreen) when everything is initialized properly.