Apps

Gradle Tutorial for Android: Getting Began – Half 2

[ad_1]

In Half 1 of this tutorial, you realized the right way to learn and construct Gradle information and the right way to handle dependencies in a number of methods. On this half, you’ll find out about barely extra advanced components of Gradle. By the top, you’ll have the ability to:

  1. Signal your releases and have totally different construct sorts.
  2. Create Gradle duties and plugins.
  3. Create construct flavors for revenue.

Getting Began

Obtain the starter challenge by clicking the Obtain Supplies hyperlink on the high or backside of the tutorial. You’ll choose up the place you left off in Half 1.

This a part of the tutorial will give attention to the right way to use Kotlin script, because it’s now the popular means of writing Gradle information. Nevertheless, each little bit of Kotlin script code may have its Groovy equal so it’s also possible to find out about it. If the choice Groovy model doesn’t exist, you possibly can assume that the particular little bit of code you’re taking a look at is similar for each circumstances.

Getting Able to Publish: Working with Product Flavors and Construct Varieties

Within the final article, you completed constructing your app. Now, you’re considering of the way to revenue from it :]

Money money money

One resolution is to have a number of variations of your app: a free model and a paid model. Thankfully, Gradle helps this on the construct degree and permits you to outline the boundaries of various construct sorts. However earlier than you get began, it is advisable perceive how Gradle permits you to work with totally different app variations.

Introducing Construct Varieties

By default, there are two construct sorts – debug and launch. The one distinction between them is the worth of the debuggable parameter. In different phrases, you need to use the debug model to evaluate logs and to debug the app, however the launch kind is used to publish your app to the Google Play Retailer. Configure properties to the construct sorts by including the next code within the android block of your module-level construct.gradle.kts file:


buildTypes {
  launch {
  }
  debug {
  }
}

Specify the type-specific settings of your utility within the debug and launch blocks.

Studying About Construct Signing

One of the vital vital configurations of the construct is its signature. With out a signature, you received’t have the ability to publish your utility as a result of it’s essential to confirm you as an proprietor of the particular utility. Whilst you don’t have to signal the debug construct – Android Studio does it routinely — the discharge construct needs to be signed by a developer.

Word: To proceed, it is advisable generate the keystore on your launch construct. Check out this tutorial to discover a step-by-step information.

When your keystore is prepared, add the code under within the android block and above the buildTypes block (the order of declaration issues) of the module-level construct.gradle.kts file:


signingConfigs {
  create("launch") {
    storeFile = file("path to your keystore file")
    storePassword = "your retailer password"
    keyAlias = "your key alias"
    keyPassword = "your key password"
  }	
}

When you’re utilizing Groovy, add this code as a substitute:


signingConfigs {
  launch {
    storeFile file("path to your keystore file")
    storePassword "your retailer password"
    keyAlias "your key alias"
    keyPassword "your key password"
  }
}

Within the signingConfigs block, specify your signature data for the construct sorts. Take note of the keystore file path. Specify it with respect to the module listing. In different phrases, in the event you created a keystore file within the module listing and named it “keystore.jks”, the worth it is best to specify might be equal to the title of the file.

Replace the buildTypes block to signal your launch construct routinely:


launch {
  signingConfig = signingConfigs.getByName("launch")
}

And the Groovy model:


launch {
  signingConfig signingConfigs.launch
}

Or, in the event you’re utilizing Groovy:

Then, make sure to hold keystorePassword.gradle.kts ignored by your model management system. Different methods embody maintaining the password in an OS-level atmosphere variable, particularly in your distant Steady Integration system, corresponding to CircleCI.

  1. When you’ve revealed your app to the Google Play Retailer, subsequent submissions should use the identical keystore file and password, so hold them protected.
  2. Be certain NOT to commit your keystore passwords to a model management system corresponding to GitHub. You are able to do so by maintaining the password in a separate file from construct.gradle.kts, say keystorePassword.gradle.kts in a Signing listing, after which referencing the file from the app module-level construct.gradle.kts through:
    
    apply(from = "../Signing/keystorePassword.gradle.kts")
    
    
    apply from: "../Signing/keystorePassword.gradle"
    

Word: There are two vital concerns associated to your keystore file:


apply(from = "../Signing/keystorePassword.gradle.kts")

apply from: "../Signing/keystorePassword.gradle"

Utilizing Construct Flavors

With a view to create a number of variations of your app, it is advisable use product flavors. Flavors are a method to differentiate the properties of an app, whether or not it’s free/paid, staging/manufacturing, and many others.

You’ll distinguish your app flavors with totally different app names. First, add the next names as strings within the strings.xml file:


<string title="app_name_free">Socializify Free</string>
<string title="app_name_paid">Socializify Paid</string>

And take away the prevailing:


<string title="app_name">Socializify</string>

Now that the unique app_name string is now not out there, edit your AndroidManifest.xml file and substitute android:label="@string/app_name" with android:label="${appName}" contained in the utility tag.

Subsequent, add the next code within the android block of your module-level construct.gradle.kts file:


// 1
flavorDimensions.add("appMode")
// 2
productFlavors {
  // 3
  create("free") {
    // 4
    dimension = "appMode"
    // 5
    applicationIdSuffix = ".free"
    // 6
    manifestPlaceholders["appName"] = "@string/app_name_free"
  }
  create("paid") {
    dimension = "appMode"
    applicationIdSuffix = ".paid"
    manifestPlaceholders["appName"] = "@string/app_name_paid"
  }
}

Right here’s what’s occurring within the code above:

  1. You might want to specify the flavour dimensions to correctly match the construct sorts. On this case, you want just one dimension – the app mode.
  2. Within the productFlavors, specify an inventory of flavors and their settings. On this case, free and paid.
  3. Specify the title of the primary product taste – free.
  4. It’s necessary to specify the dimension parameter worth. The free taste belongs to the appMode dimension.
  5. Because you wish to create separate apps without spending a dime and paid performance, you want them to have totally different app identifiers. The applicationIdSuffix parameter defines a string that’ll be appended to the applicationId, giving your app distinctive identifiers.
  6. The manifestPlaceholders permits you to modify properties in your AndroidManifest.xml file at construct time. On this case, modify the appliance title relying on its model.

The Groovy equal can be:


// 1
flavorDimensions = ["appMode"]
// 2
productFlavors {
  // 3
  free {
    // 4
    dimension "appMode"
    // 5
    applicationIdSuffix ".free"
    // 6
    manifestPlaceholders.appName = "@string/app_name_free"
  }
  paid {
    dimension "appMode"
    applicationIdSuffix ".paid"
    manifestPlaceholders.appName = "@string/app_name_paid"
  }
}

Sync your challenge with Gradle once more. After the challenge sync, run the duties command, and see in the event you can spot what’s modified:

./gradlew duties

You’ll get an identical listing of duties to the one you bought while you ran this command the primary time:


...
Construct duties
-----------
...
assembleDebug - Assembles primary outputs for all Debug variants.
assembleFree - Assembles primary outputs for all Free variants.
assemblePaid - Assembles primary outputs for all Paid variants.
assembleRelease - Assembles primary outputs for all Launch variants.
...

Spot the distinction? Take a look at the duties beneath the Construct duties part, and also you’ll see some new ones there. You now have separate instructions for every construct kind and construct taste.

Run the command:

./gradlew assembleDebug

When the command completes, verify the output listing:


ls -R app/construct/outputs/apk

Right here’s what you’ll see:


free paid

app/construct/outputs/apk/free:
debug

app/construct/outputs/apk/free/debug:
app-free-debug.apk   output-metadata.json

app/construct/outputs/apk/paid:
debug

app/construct/outputs/apk/paid/debug:
app-paid-debug.apk   output-metadata.json

You need to have two builds generated – freeDebug and paidDebug.

[ad_2]

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button