A Step-By-Step Guide To Set up Fastlane In React Native

Quick Summary

Table of Contents

What is Fastlane?

Fastlane is a simple yet effective way to automate deployments and releases for your iOS and Android applications. It is a platform that delivers high-quality applications via continuous deployment without hampering the speed and agility of your development team’s daily tasks. It enables iOS and Android developers to create and upload ABB/APK/IPA time operations.

It also offers native Gradle (Android) and Xcode (iOS) plugins and a Ruby command line utility. It handles tasks such as signing up for the App Store and Google Play, publishing applications to stores, thereby deploying beta software, Firebase Crashlytics, and more. The Flastlane is ideally compatible with any of your Continuous Integration systems

Steps To Set up Fastlane in React Native

As we know, manually generating and uploading an application (ABB/APK/IPA) on the store takes longer and is tiring, specifically with the iOS credentials and certificates. So, Fastlane here comes to the rescue.

Now, let us move ahead with the steps to set up Fastlane in the system:

Prerequisites

Moving ahead with the steps to set up Fastlane within the system, you will need to follow the prerequisites below, including some software packages and store accounts, before starting to implement this feature.

• NodeJS
• Android Studio
• XCode
• Google Play Console Account and the setup App Android on Play Store
• Apple Developer Account and the setup of iOS App on the App Store.

Initially, set up the git branch:

git checkout main

Setting up Fastlane

You can install Fastlane with Homebrew for macOS using the command given below:

brew install fastlane

Then, create a Fastlane folder at the root of the React Native project. Then, create a file called Fastfile within this directory.

The Fastfile is where we configure Fastlane commands, lane, and actions code. A lane contains a group of actions to be executed synchronously to automate a process. An action is a function that performs a task.

In this file, we have defined two platforms, Android and iOS. They will contain the specific lanes for each context. Having the platforms defined allows us to execute lanes like that:

 fastlane ios lane and fastlane android lane

Setup iOS Lanes

The best way to code sign its match; before integrating the match into a lane, you have to:

• Nuke the existing profiles and certificates.
• Setup match through the init option.
• Create a lane on the iOS platform that uses match.

Setup Match

fastlane match init

Then, it will ask if you want to store your code signing identities inside a Git repo, Google Cloud, or Amazon S3.

For now, we will use the git option.

fastlane match App Store

Setup Nuke

fastlane match nuke distribution

Create a lane on the iOS platform that uses match:

platform :ios do

desc 'Setup profile and certificate'
lane :certificates do
  match(app_identifier: 'com.fastlanedemo', type: 'App Store', readonly: true)
end

desc 'iOS build setup.'
private_lane :build do
  certificates
  increment_build_number(xcodeproj: './ios/fastlaneDemo.xcodeproj')
  gym(scheme: fastlaneDemo, project: './ios/fastlaneDemo.xcodeproj')
end

desc Upload to Testflight.'
  lane :beta do
    build
    pilot
    commit_version_bump(message: 'Upload build', xcodeproj: './ios/fastlaneDemo.xcodeproj')
    push_to_git_remote
  end

end

In the certificate’s lane, we have a match that will automatically save the provisioning profiles and certs on your OS X Keychain.

To set up the iOS build, we will create a lane that uses the certificates’ lane we have created before and gym to compile our application. Then, we want to increment the build number to ship our application to beta testing services.

The beta lane will use the build lane to provide a signed .ipa to Pilot, then it will commit and push in the setup branch by increasing the build number, and finally, it will upload the local build to Testflight.

Run the iOS beta lane:
To execute the iOS beta lane, run the below command:

fastlane ios beta

Setup Android Lanes

First, you must generate or fetch the signing key(Keystore) and add it to the project.

Then, when you build an Android application using the assemble task in Release mode, the application will be signed.

platform :android do

desc 'Generate Android APK.'

private_lane :build do
  gradle(task: 'clean', project_dir: 'android/')
  gradle(task: 'assemble', build_type: 'Release', project_dir: 'android/')
end

desc 'Upload APK on Play Store.'
  lane :beta do
    build
    supply(track: 'beta', track_promote_to: 'beta')
    git_commit(path: ['./android/gradle.properties'], message: 'Upload versionCode')
    push_to_git_remote
  end

end

To generate a signed .apk, we will create a build lane.

Now we have two Gradle actions. The first action will clean the Gradle, and the second will create and assemble a release build.

Then, automate the versionCode bump by hooking up the assembleRelease with this little task.

The beta lane for uploading APK on Play Store. Beta uses the build lane for the build lane to generate the signed .apk, commits the versionCode changes, and uses Supply to promote the local build to Play Store as a beta release.

Run the Android beta lane:
To execute the Android beta lane, run the below command

fastlane android beta

Conclusion