Play Store Uploads with Fastlane Supply - 4

If you’ve ever manually uploaded an APK or AAB to the Google Play Store, you know it can be a tedious process. From filling out all the necessary metadata to selecting the correct APK version, it can feel like a lot of repetitive work. But with Fastlane Supply, you can automate this entire process — making your app releases smoother, faster, and error-free.

In this section, we’ll explore how Fastlane Supply works and how to set it up to upload your Android app directly to the Play Store with ease.

Step 1: Set Up Google Play API Access

Before you can upload your app with Fastlane Supply, you need to set up Google Play API access. This ensures that Fastlane can communicate with the Play Store and upload your APK or AAB.

Here’s how you can set up API access:

1. Create a Google Cloud project:

• Go to the Google Cloud Console.
• Create a new project.

1. Enable the Google Play Developer API:

• In the Cloud Console, search for and enable the Google Play Developer API.

1. Create a service account:

• In the Cloud Console, go to IAM & Admin > Service Accounts.
• Create a new service account and give it the role of “Play Store API” (or the necessary roles for uploading apps).
• Download the JSON key file for this service account.

1. Upload the JSON key to your project:

• Place the downloaded JSON key file in your Android project directory (or a secure location that’s easy to reference).

Step 2: Configure Fastlane Supply in Your Fastfile

Now that you have API access set up, you can configure Fastlane Supply in your Fastfile to automate the upload process.

Basic Upload Configuration

Here’s an example of how to add supply to your Fastfile for a simple upload:

platform :android do
  desc "Build the app and upload it to the Play Store"
  lane :release do
    gradle(task: "assembleRelease") # Builds the app
    upload_to_play_store # Uploads the app to the Play Store
  end
end

• gradle(task: “assembleRelease”): This command tells Fastlane to build the APK or AAB using Gradle.
• upload_to_play_store: This is the key command that tells Fastlane to upload the APK or AAB to the Play Store.

Configuring API Credentials

Next, you need to tell Fastlane where your Google Play API credentials are stored. If you’ve placed the JSON key file in your project directory, you can configure Fastlane like this:

upload_to_play_store(
  json_key: "path/to/your-service-account.json" # Provide the path to your JSON key file
)

This will ensure that Fastlane uses the correct API credentials to authenticate with the Google Play Store.

Step 3: Manage Version Codes and Release Tracks

One of the great things about Fastlane Supply is that it can manage version codes and release tracks for you. When you upload a new version of your app, Fastlane will automatically increment the version code and handle the distribution to the appropriate track (e.g., Production, Beta, or Alpha).

You can specify which track to upload your app to by adding the track option:

upload_to_play_store(
  track: "beta" # Upload to the Beta track for testing
)

This will ensure that your app gets uploaded to the correct release track. You can also set up different lanes for different tracks:

platform :android do
  desc "Upload to Play Store Beta"
  lane :beta do
    gradle(task: "assembleRelease")
    upload_to_play_store(track: "beta")
  end

  desc "Upload to Play Store Production"
  lane :production do
    gradle(task: "assembleRelease")
    upload_to_play_store(track: "production")
  end
end

Step 4: Automate Version Management (Optional)

Fastlane can also automate version code management. This is especially useful for preventing version code conflicts when uploading your APK or AAB.

To automate the increment of the versionCode, you can use the increment_version_code action in your Fastfile:

platform :android do
  desc "Increment version code, build, and upload"
  lane :release do
    increment_version_code # Automatically increments the version code
    gradle(task: "assembleRelease")
    upload_to_play_store
  end
end

This will automatically bump the version code each time you upload a new version, ensuring you don’t run into version conflicts.

Step 5: Run Your Upload Lane

Now that everything is set up, you can trigger the upload process with a simple command:

fastlane release

This command will:

1. Build your app using Gradle.
2. Upload your APK or AAB to the specified track on the Google Play Store.

If you’ve set up different tracks (like beta or production), you can use specific lanes to target each one:

fastlane beta

or

fastlane production

Fastlane will take care of uploading your app to the appropriate track with the correct version code.

Step 6: Optional — Handle Metadata

If you want to automate the management of metadata (like app description, screenshots, or release notes), Fastlane Supply can help with that too. Here’s an example:

upload_to_play_store(
  metadata_path: "./metadata" # Path to folder with metadata files
)

Fastlane will automatically upload the metadata (such as the description and screenshots) along with the APK or AAB. This can save you a lot of time when releasing updates.

Wrapping Up

With Fastlane Supply, you’ve completely automated the process of uploading your Android app to the Google Play Store. Whether you’re uploading a new version to beta for testing or pushing to production for your users, Fastlane handles it all.

By integrating Fastlane into your workflow, you save time, reduce the risk of errors, and ensure your app releases are always smooth and consistent. So go ahead — let Fastlane take care of the Play Store uploads, and get back to developing your next great feature!

LinkedIn: https://www.linkedin.com/in/vikas-soni-052013160/

Email: vikasacsoni9211@gmail.com