Skip to main content

ZERO TO STORES GUIDE

Deploy Live Updates

Tutorial Video

Video recording in progress. Available soon.

Let's continue our journey to creating the ideal app distribution pipeline by integrating code push updates. For this part we will use Shorebird which is code push solution for Flutter. Shorebird has been built by none other than Felix Angelov and Eric Seidel.

Understanding Code Push and Shorebird​

Code push lets you update your app without submitting a new build to the app stores. Think of it like a web app update - users get the new features next time they open the app.

An important note is that patches are linked to a specific version of your app. When building a patch, you need to specify the version of the app you want to patch. This makes the use of shorebird in production a bit more complex than it might seem at first glance.

At Codika we've built our release pipeline to ensure that we can create patches for any version of the app easily.

How Code Push Works

Here's the magic behind it:

  1. When building your app, Shorebird adds a special updater that can safely modify your app's code
  2. When you create a patch, Shorebird looks at what Dart code changed and creates a small update package
  3. This patch gets uploaded to Shorebird's servers
  4. When users open your app, it quietly checks if there's a new patch available
  5. If found, it downloads that patch
  6. Next time the app starts, the patch is applied and the changes are live!

Limitations

This only works for Dart code changes (your app's logic, UI, etc.). Changes to native code or adding packages are not supported.

Shorebird Integration​

If you followed along with the zero to stores guide, your app already has Shorebird built in!

The codika create command used the Shorebird CLI to add the necessary configuration, and the codika codemagic setup command added specific workflows for patch builds.

This means that you can start creating patches right away.

Creating Your First Patch​

Codika enforces a strict workflow for creating patches. Patches can only be created from version branches. Since versions branches are automatically created when you create a new version with codika app release, you can create a patch for any version of your app once you have a version branch.

To switch to the version branch, you can use the following command:

codika app checkout

The command will ask you what environment and what version you want to go to. For the sake of this guide, please navigate to the staging environment and version 1.0.1. You could also use arguments to specify the environment and version.

codika app checkout --env staging --version 1.0.1

Your IDE now shows the code of the release you created in the previous step. Let's make some changes to the app, we'll change the counter app to include a decrement button. In the main.dart file do the following changes:

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  void _incrementCounter() {...}

  // Add this method
  void _decrementCounter() {
    setState(() {
      if (_counter > 0) {
        _counter--;
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: ...,
      body: ...,
      // Change the floating action button to a row with two buttons
      floatingActionButton: Row(
        mainAxisAlignment: MainAxisAlignment.end,
        spacing: 16,
        children: [
          FloatingActionButton(
            onPressed: _decrementCounter,
            tooltip: 'Decrement',
            child: const Icon(Icons.remove),
          ),
          FloatingActionButton(
            onPressed: _incrementCounter,
            tooltip: 'Increment',
            child: const Icon(Icons.add),
          ),
        ],
      ),
    );
  }
}

Once you've made the changes, make sure to commit and push your changes. Then you can create a patch with the following command:

codika app patch

The command will start by verifying that you are indeed on a version branch and that all local modifications are committed and pushed. If everything is fine, it will create a new branch named release/v1.0.1-stag-patch.

This branch creation will trigger a new Codemagic build for the patch. Once the build is finished, you can see the patch in the Shorebird dashboard.

Next Patches​

Shorebird doesn't limit the number of patches you can create for a given version. For future patches, you would need to navigate to the version branch again, make the changes and run the codika app patch command again. This time the command would push the changes on the same patch branch release/v1.0.1-stag-patch.

App Versions Overview​

If you now run the codika app versions command, you should see a +1 next to the version 1.0.1 in the staging environment.

$ codika app versions

╭───────────┬───────────────┬────────╮
│ Version   │     Stag      │  Prod  │
├───────────┼───────────────┼────────┤
│ 1.0.1     │       ● (+1)  │        │
╰───────────┴───────────────┴────────╯

What's Next?​

Congratulations! You've just:

  • Learned about code push updates
  • Created your first Shorebird patch with Codika
  • Deployed changes without app store involvement

In the next section, we'll explore how to promote your app from one environment to another. We will promote the staging version to production and see how to create a patch for the production version.