Implementing In-App Updates in Flutter

In the dynamic world of mobile app development, keeping users up-to-date with the latest features, bug fixes, and performance improvements is crucial. Implementing in-app updates allows your users to seamlessly update your Flutter application without leaving the app. This ensures they are always running the best version, enhancing user experience and app stability.

What are In-App Updates?

In-app updates are a feature provided by Google Play that allows Android apps to prompt users to update their app while they are using it. Instead of redirecting users to the Google Play Store, the update process happens directly within the app, making it more convenient and less disruptive.

Why Use In-App Updates?

• Improved User Experience: Seamless updates without leaving the app.
• Increased Adoption Rate: Higher likelihood of users updating compared to manual updates.
• Better Control: Developers can enforce critical updates and provide better support for new features.
• Enhanced Security: Quick deployment of security patches.

Implementing In-App Updates in Flutter

To implement in-app updates in Flutter, we use the in_app_update plugin. This plugin provides the necessary methods to check for updates, initiate updates, and handle different update states.

Step 1: Add Dependency

First, add the in_app_update plugin to your pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  in_app_update: ^3.0.0 # Use the latest version

Run flutter pub get to install the dependency.

Step 2: Configure Android Project

Ensure your Android project is properly configured to support in-app updates. In your android/app/build.gradle file, set the minSdkVersion to 21 or higher:

android {
    compileSdkVersion 33
    
    defaultConfig {
        applicationId "your.package.name"
        minSdkVersion 21
        targetSdkVersion 33
        versionCode flutterVersionCode.toInteger()
        versionName flutterVersionName
    }
    ...
}

Step 3: Implement the Update Logic

Now, let’s implement the code to check for and initiate in-app updates. Here’s a basic example:

import 'package:flutter/material.dart';
import 'package:in_app_update/in_app_update.dart';

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'In-App Updates Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State {
  AppUpdateInfo? _updateInfo;

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

  Future checkForUpdate() async {
    InAppUpdate appUpdateInfo = InAppUpdate();

    try {
      final updateInfo = await appUpdateInfo.checkForUpdate();
      setState(() {
        _updateInfo = updateInfo;
      });

      if (updateInfo?.availableVersionCode != null) {
        promptForUpdate(updateInfo);
      } else {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('No update available.')),
        );
      }
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error checking for update: $e')),
      );
    }
  }

  void promptForUpdate(AppUpdateInfo updateInfo) {
    if (updateInfo.updateAvailability == UpdateAvailability.developerTriggeredUpdateInProgress) {
      // If an in-app update is already running, resume the update.
      appUpdateInfo.completeUpdate();
    }
    
    showDialog(
      context: context,
      builder: (BuildContext context) {
        return AlertDialog(
          title: Text('Update Available'),
          content: Text('A new version of the app is available. Update now?'),
          actions: [
            TextButton(
              onPressed: () {
                Navigator.of(context).pop();
              },
              child: Text('Later'),
            ),
            TextButton(
              onPressed: () {
                Navigator.of(context).pop();
                startUpdate(updateInfo);
              },
              child: Text('Update'),
            ),
          ],
        );
      },
    );
  }


  Future startUpdate(AppUpdateInfo updateInfo) async {
    try {
      await InAppUpdate.startFlexibleUpdate();
        // or use
        //await InAppUpdate.startImmediateUpdate();
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error starting update: $e')),
      );
    }
  }


  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('In-App Updates Demo'),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              'Welcome to the app!',
              style: TextStyle(fontSize: 20),
            ),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: checkForUpdate,
              child: Text('Check for Update'),
            ),
          ],
        ),
      ),
    );
  }
}

Step 4: Handling Update Types

The in_app_update plugin supports two types of updates: flexible and immediate.

Flexible Updates

Flexible updates allow the user to continue using the app while the update downloads in the background. After the download is complete, the user is prompted to install the update.

Future startFlexibleUpdate() async {
  try {
    await InAppUpdate.startFlexibleUpdate();
  } catch (e) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text('Error starting flexible update: $e')),
    );
  }
}

To complete the flexible update, use:

InAppUpdate.completeUpdate();

Immediate Updates

Immediate updates require the user to update the app before continuing to use it. This is suitable for critical updates.

Future startImmediateUpdate() async {
  try {
    await InAppUpdate.startImmediateUpdate();
  } catch (e) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text('Error starting immediate update: $e')),
    );
  }
}

Step 5: Error Handling

Proper error handling is essential for a smooth user experience. Wrap the update calls in try-catch blocks to handle any potential errors.

try {
  final updateInfo = await InAppUpdate.checkForUpdate();
  // ...
} catch (e) {
  ScaffoldMessenger.of(context).showSnackBar(
    SnackBar(content: Text('Error checking for update: $e')),
  );
}

Testing In-App Updates

Testing in-app updates requires publishing your app to the Google Play Store internal test track. Here’s a brief overview of the testing process:

1. Upload your app to the Google Play Console’s internal test track.
2. Add testers to your internal test group.
3. Have testers install the app via the Play Store.
4. Release a new version of the app in the internal test track and verify that in-app updates are triggered.

Conclusion

Implementing in-app updates in Flutter can significantly improve your app’s user experience by ensuring users are always running the latest version. Using the in_app_update plugin, developers can easily integrate this feature and provide seamless updates. By handling different update types and potential errors effectively, you can create a robust update mechanism that keeps your app secure and up-to-date.