Lightbuild और Kotlin DSL की तुलना करना

अगर आपको Kotlin DSL की मदद से Android बिल्ड कॉन्फ़िगर करने के बारे में पता है, तो इस पेज पर बताया गया है कि Kotlin DSL के सामान्य कॉन्फ़िगरेशन, Lightbuild पर कैसे मैप होते हैं.

इस पेज पर दिए गए उदाहरणों में, Kotlin डीएसएल और Android Gradle प्लगिन (एजीपी) 9.0 या इसके बाद के वर्शन का इस्तेमाल किया गया है. इसमें Kotlin के लिए पहले से मौजूद सहायता शामिल है.

बिल्ड फ़ाइलें

यहां दी गई टेबल में, हर Kotlin DSL बिल्ड फ़ाइल के लिए Lightbuild का विकल्प दिखाया गया है:

प्रोजेक्ट सेटिंग

Kotlin DSL में, settings.gradle.kts फ़ाइल में प्रोजेक्ट का नाम, उसके मॉड्यूल, और डिपेंडेंसी को हल करने के लिए रिपॉज़िटरी के बारे में बताया जाता है:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "MyApp"
include(":app")
include(":app-core")

Lightbuild में, project.lightbuild.yaml फ़ाइल में ये सेटिंग तय की जाती हैं:

project:
  name: MyApp
modules:
  - app
  - app-core
repositories:
  - google
  - mavenCentral

इस टेबल में, पूरे प्रोजेक्ट के लिए लागू होने वाली सेटिंग की तुलना की गई है:

मॉड्यूल टाइप और प्लगिन

Kotlin DSL में, प्लगिन लागू करके मॉड्यूल का टाइप चुना जाता है. साथ ही, केएसपी जैसी सुविधाएं जोड़ने के लिए, अन्य प्लगिन लागू किए जाते हैं. Lightbuild में, मॉड्यूल का type सेट किया जाता है. इसके बाद, Lightbuild आपके कॉन्फ़िगरेशन के लिए ज़रूरी सुविधाएं लागू करता है:

Android सेटिंग

Kotlin DSL में, मॉड्यूल की build.gradle.kts फ़ाइल के android ब्लॉक में Android सेटिंग कॉन्फ़िगर की जाती हैं:

plugins {
    id("com.android.application")
}

android {
    namespace = "com.example.myapp.app"
    compileSdk = 36

    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 24
        targetSdk = 36
        versionCode = 1
        versionName = "1.0"
    }
}

Lightbuild में, किसी मॉड्यूल की lightbuild.yaml फ़ाइल के android ब्लॉक में वही सेटिंग कॉन्फ़िगर की जाती हैं:

platform: android
type: application
android:
  namespace: com.example.myapp.app
  compileSdk:
    version:
      release:
        apiLevel: 36
  minSdk:
    version:
      release:
        apiLevel: 24
  targetSdk:
    version:
      release:
        apiLevel: 36
  applicationId: com.example.myapp
  versionCode: 1
  versionName: "1.0"

यहां दी गई टेबल में, इन सेटिंग की तुलना की गई है:

डिपेंडेंसी

Kotlin DSL में, dependencies ब्लॉक में डिपेंडेंसी का एलान किया जाता है. इसके लिए, implementation जैसे कॉन्फ़िगरेशन का इस्तेमाल किया जाता है:

dependencies {
    implementation(project(":app-core"))
    implementation("androidx.core:core-ktx:1.18.0")
}

Lightbuild में, मॉड्यूल डिपेंडेंसी को module के तहत और बाहरी लाइब्रेरी को maven के तहत लिस्ट किया जाता है:

android:
  dependencies:
    module:
      - //app-core
    maven:
      - androidx.core:core-ktx:1.18.0

Kotlin DSL, api, compileOnly, और runtimeOnly जैसे अन्य कॉन्फ़िगरेशन का इस्तेमाल करता है. इससे यह कंट्रोल किया जाता है कि कोई मॉड्यूल, डिपेंडेंसी का इस्तेमाल कैसे करता है:

dependencies {
    api(project(":data"))
    compileOnly("androidx.annotation:annotation:1.9.1")
}

Lightbuild में, डिपेंडेंसी में compile और runtime सेटिंग जोड़ी जाती हैं:

android:
  dependencies:
    module:
      - //data:
          compile: public
    maven:
      - androidx.annotation:annotation:1.9.1:
          runtime: off

इन सेटिंग के बारे में ज़्यादा जानने के लिए, डिपेंडेंसी सेटिंग देखें.

यहां दी गई टेबल में, डिपेंडेंसी के सामान्य एलान की तुलना की गई है:

केएसपी

Kotlin DSL में, केएसपी प्लग इन लागू करें और ksp कॉन्फ़िगरेशन की मदद से प्रोसेसर जोड़ें:

plugins {
    id("com.android.library")
    id("com.google.devtools.ksp")
}

dependencies {
    implementation("com.squareup.moshi:moshi:1.15.2")
    implementation("com.squareup.moshi:moshi-kotlin:1.15.2")
    ksp("com.squareup.moshi:moshi-kotlin-codegen:1.15.2")
}

Lightbuild में, kspProcessors ब्लॉक में प्रोसेसर जोड़े जाते हैं. इसके बाद, Lightbuild केएसपी प्लगिन को अपने-आप लागू कर देता है:

type: library
android:
  dependencies:
    maven:
      - com.squareup.moshi:moshi:1.15.2
      - com.squareup.moshi:moshi-kotlin:1.15.2
  kspProcessors:
    maven:
      - com.squareup.moshi:moshi-kotlin-codegen:1.15.2

टेस्ट अपडेट

Kotlin DSL में, इंस्ट्रुमेंटेशन टेस्ट रनर को defaultConfig में सेट किया जाता है. साथ ही, testImplementation और androidTestImplementation कॉन्फ़िगरेशन की मदद से टेस्ट डिपेंडेंसी जोड़ी जाती हैं:

android {
    defaultConfig {
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.3.0")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
}

Lightbuild में, लोकल टेस्ट को tests.test में और इंस्ट्रुमेंटेड टेस्ट को tests.androidTest में कॉन्फ़िगर किया जाता है:

android:
  tests:
    test:
      dependencies:
        maven:
          - junit:junit:4.13.2
    androidTest:
      runner: androidx.test.runner.AndroidJUnitRunner
      dependencies:
        maven:
          - androidx.test.ext:junit:1.3.0
          - androidx.test.espresso:espresso-core:3.7.0

निर्देश बनाएं

Kotlin DSL की मदद से, Gradle रैपर के साथ Gradle टास्क चलाकर, कमांड लाइन से ऐप्लिकेशन बनाया और टेस्ट किया जा सकता है. Lightbuild के साथ, Lightbuild सीएलआई का इस्तेमाल किया जाता है.

ज़्यादा जानकारी के लिए, कमांड लाइन से अपना ऐप्लिकेशन बनाएं और कमांड लाइन से Lightbuild प्रोजेक्ट बनाएं लेख पढ़ें.

डिपेंडेंसी लॉक करना

Kotlin DSL के साथ, डिपेंडेंसी लॉक करना ज़रूरी नहीं है: इसे अपनी बिल्ड स्क्रिप्ट में चालू करें. इसके बाद, --write-locks फ़्लैग के साथ बिल्ड चलाकर lockfiles लिखें. Lightbuild में, हर मॉड्यूल में एक resolved.deps फ़ाइल होती है. इसमें मॉड्यूल की रिज़ॉल्व की गई डिपेंडेंसी रिकॉर्ड होती हैं. Lightbuild, इस फ़ाइल को अपने-आप जनरेट करता है. Gradle लॉकफ़ाइलों की तरह, वर्शन कंट्रोल के लिए अपनी resolved.deps फ़ाइलों को चेक इन करें.

अपनी डिपेंडेंसी लॉक करने के लिए, उदाहरण के लिए, सीआई बिल्ड में, lightbuild resolve या lightbuild test में --locked-dependencies फ़्लैग जोड़ें. इस फ़्लैग का इस्तेमाल करने पर, अगर कोई resolved.deps फ़ाइल, मॉड्यूल की डिपेंडेंसी से मेल नहीं खाती है, तो फ़ाइल को अपडेट करने के बजाय कमांड काम नहीं करता:

lightbuild resolve --locked-dependencies

ये सुविधाएं, Google Play Books के साथ काम नहीं करतीं

Lightbuild में Kotlin DSL की ये सुविधाएं काम नहीं करतीं:

• वर्शन कैटलॉग और कन्वेंशन प्लगिन
• कस्टम प्लग इन
• प्रॉडक्ट के फ़्लेवर. इसके बजाय, अपने ऐप्लिकेशन के हर वर्शन के लिए एक अलग ऐप्लिकेशन मॉड्यूल बनाएं. ज़्यादा जानकारी के लिए, एक से ज़्यादा ऐप्लिकेशन मॉड्यूल लेख पढ़ें.
• Kotlin Multiplatform (KMP) मॉड्यूल
• प्रॉक्सी सर्वर के ज़रिए डिपेंडेंसी रिज़ॉल्यूशन

इसके अलावा, किसी प्रोजेक्ट में Kotlin DSL और Lightbuild मॉड्यूल को मिक्स नहीं किया जा सकता. पहले से मौजूद समस्याओं के बारे में जानने के लिए, Lightbuild के रिलीज़ नोट देखें.