Ek React Native App Ki Poori Kahani 😉

Chapter 1: Developer Ki Zindagi – Code Likho, Build Se Daro

Ek React Native developer ki zindagi ka sabse peaceful moment hota hai jab app locally chal rahi hoti hai.
Metro bundler smooth chal raha hai.
UI perfect lag rahi hai.
API response aa raha hai.

Phir ek sentence sunne ko milta hai:

Release bana do.

Yahin se asli struggle start hota hai.
Android Studio open hota hai.
Gradle build start karta hai.
Kabhi versionCode duplicate.
Kabhi keystore missing.
Kabhi Java version galat.

Har release me same drama.
Is point par developer samajh jaata hai — problem code nahi, process hai.

Chapter 2: CI/CD Ka Concept – Automation Ka Janam

CI/CD ka idea simple hai, par powerful.

Tum developer ho.
Tumhara kaam code likhna hai.

Build banana, version badhana, sign karna, store upload karna — ye sab machine ka kaam hai.

CI/CD bolta hai:

Tum bas code push karo, baaki main sambhal lunga.

React Native ke case me CI/CD ka role aur bhi important ho jaata hai kyunki:

Android aur iOS dono handle karne hote hain

Signing sensitive hoti hai

Play Store strict hota hai

Chapter 3: Android Project Ko Discipline Sikhana

CI/CD tab kaam karta hai jab Android project disciplined ho.

Sabse pehle Android folder ko samajhna padta hai.

build.gradle (app-level)
android {
    defaultConfig {
        applicationId "com.myapp"
        minSdkVersion 23
        targetSdkVersion 34
        versionCode 1
        versionName "1.0.0"
    }
}

Yahan do cheezein important hain:

versionCode Play Store ke liye unique hona chahiye

versionName user ko dikhai deta hai

Fastlane baad me versionCode ko automatically increment karega, isliye yahan ka structure clean hona chahiye.

Chapter 4: Signing – Android Ka Sabse Sensitive Topic

Android bina signing ke release nahi hota.
Aur signing galat ho jaaye to Play Store app reject kar deta hai.

Keystore Properties File
storePassword=*****
keyPassword=*****
keyAlias=release
storeFile=release.keystore

Ye file:

Git me kabhi nahi jaati

CI/CD ke secrets se load hoti hai

build.gradle me Signing Config
signingConfigs {
    release {
        storeFile file(System.getenv("KEYSTORE_PATH"))
        storePassword System.getenv("KEYSTORE_PASSWORD")
        keyAlias System.getenv("KEY_ALIAS")
        keyPassword System.getenv("KEY_PASSWORD")
    }
}

Iska matlab:

CI/CD environment variables supply karega

Code secure rahega

Manual password typing khatam

Chapter 5: Play Store Ki Demand – AAB Chahiye

Play Store ko APK nahi, AAB chahiye.

Isliye CI/CD pipeline ka main Android command hota hai:

./gradlew bundleRelease

Output yahan milta hai:

app/build/outputs/bundle/release/app-release.aab

Ye file hi Play Store ka ticket hai.

Chapter 6: Fastlane Ki Entry – Automation Ka Brain

Fastlane Android automation ka dimaag hai.

Gradle sirf build karta hai.
Fastlane build aur release dono karta hai.

Fastlane Install

cd android
gem install fastlane
fastlane init

Fastlane yahin poochta hai:
Play Store setup chahiye?

Aur tum bolte ho:
Haan, hamesha ke liye.

Chapter 7: Fastlane Folder Structure Samajhna

Fastlane init ke baad structure aisa hota hai:

android/fastlane/
 ├── Appfile
 ├── Fastfile
 └── metadata/

Appfile → App ki identity

Fastfile → Automation logic

metadata → Play Store content

Yahin se poora release control hota hai.

Chapter 8: Appfile – Fastlane Ko Batana Tum Kaun Ho

Fastlane ko ye batana zaroori hai:

App ka package name kya hai

Play Store access kahan se milega

package_name("com.myapp")
json_key_file("playstore-key.json")

playstore-key.json:

Google service account file hoti hai

CI/CD secrets me stored hoti hai

Gitignore me hoti hai

Chapter 9: Fastfile – Kahani Ka Script

Fastfile me hum Fastlane ko batate hain:
Kab kya karna hai.

Basic Release Lane

platform :android do
  lane :release do
    increment_version_code(
      gradle_file_path: "app/build.gradle"
    )

    gradle(
      task: "bundle",
      build_type: "Release"
    )

    upload_to_play_store(
      track: "internal",
      aab: "app/build/outputs/bundle/release/app-release.aab"
    )
  end
end

Is lane ka matlab:

VersionCode automatically badhega

Release AAB banega

Internal testing track me upload hoga

Chapter 10: CI/CD + Fastlane – Perfect Team

CI/CD pipeline ka kaam sirf Fastlane ko chalana hai.

cd android
bundle install
fastlane release

Fastlane ke baad:

Gradle run hota hai

Signing apply hoti hai

Play Store upload ho jaata hai

CI/CD aur Fastlane ek dusre ke bina adhoore hain.

Chapter 11: Environment Handling – Same App, Different Mood

Real apps me ek hi backend nahi hota.

Dev
Staging
Production

Fastlane environment ke hisaab se build karta hai:

ENVFILE=.env.prod fastlane release

Isse production API ke saath release hota hai.

Chapter 12: Play Store Metadata – Sirf Code Kaafi Nahi

Play Store sirf app nahi, presentation bhi dekhta hai.

Fastlane metadata folder:

fastlane/metadata/android/en-US/
 ├── title.txt
 ├── short_description.txt
 └── full_description.txt

Next release me description update karne ke liye Play Console kholna bhi zaroori nahi.

Chapter 13: Security – Secrets Jo Sirf Pipeline Jaane

CI/CD + Fastlane me ye sab secrets safe rehte hain:

Keystore passwords

Play Store JSON key

Signing configs

Code clean rehta hai.
Repo secure rehta hai.

Chapter 14: Real Problems – Kyunki Ye Real Life Hai

Kabhi-kabhi issues aate hain:

VersionCode duplicate

Wrong package name

Permission missing

Gradle cache issues

Par ek baar solve ho jaaye, Fastlane reliable system ban jaata hai.

Final Chapter: Moral Of The Kahani

React Native Android app ke liye:

Manual build = temporary solution
CI/CD + Fastlane = permanent system

Tum developer ho.
Tumhara kaam code likhna hai.

Build banana, version badhana, Play Store upload —
ye automation ka kaam hai. Fastlane is kahani ka hero hai.

Aur yeh sab krne se phele apko ghabrana nhi hai ...😁