Android (20 Part Series)

1 Android activity and lifecycle
2 The Basics of a Fragment
… 16 more parts…
3 Basic Fragment implementation with Android.
4 Getting Groovy in Android with module level build files in Gradle
5 Understanding specifics of the Android build file.
6 RecyclerView Activity implementation.
7 Creating a solid understanding of Android Fragments
8 Adding OnClickListener to RecyclerView in Android
9 A light introduction to the Android intent system
10 Navigating Android Fragments with the Navigation Component
11 What is SQLite?
12 Room database. Entities
13 Room database. DOAs
14 Android Room database
15 Room database. Repository
16 Room database. ViewModel
17 Room database. RecyclerView Part 1
18 Room database. RecyclerView Part 2
19 Asynchronous queries in Android.
20 Android Runtime and Dalvik

Introduction

This series is going to be dedicated to the basic to Android development. Join me and let us try to build and understand some cool stuff. This post will be on understanding what the properties of our build files do. If you are unfamiliar with the syntax of the build files, please take a look at my previous post located HERE

Getting started

The first thing I am going to do is paste the code and then we will walk through the code line by line until we are done.

plugins {
    id 'com.android.application'

}

android {
    compileSdkVersion 30

    defaultConfig {
        applicationId "com.example.criminalintent"
        minSdkVersion 23
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {

        release {
            println(getDelegate())
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8

    }
}

dependencies {

    implementation 'androidx.appcompat:appcompat:1.3.0'
    implementation 'com.google.android.material:material:1.3.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    implementation 'androidx.recyclerview:recyclerview:1.2.1'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}

Enter fullscreen mode Exit fullscreen mode

Plugins

The plugin block of code(plugin DSL) is where we define the plugins our app uses. If you are unfamiliar with plugins just remember they make the wheels go round in Gradle.
id 'com.android.application' is a plugin the provides Gradle with specific features that are unique to building Android apps. Without this plugin our app will not build. If you are interested about plugins, HERE is a link to the official Gradle plugin repository.

android{…}

This marks the starting point of where to enter all the specific android build configurations.

compileSdkVersion 30

This indicates the API level our app will be compiled with. In other words, you can not use features from an API that is higher than the value specified here. For us that API level is 30.

defaultConfig{…}

Inside this block we specify defaults for variant properties that the Android plugin applies to all build variants(release,debug…).

applicationId “com.example.criminalintent”

Every app has this Id and it uniquely identifies the app on devices and in the google play store. Although the application ID looks like a traditional Java Package name, the naming convention actually has rules.
1): It must have at least 2 segments(one or more dots)
2): Each segment must start with a letter
3): All characters must be alphanumeric or an underscore [a-zA-Z0-9_]

minSdkVersion 23

Marks the minimum version of the Android platform on which the app will run.

targetSdkVersion 30

Specifies the API level on which the app is designed to run.

versionCode 1

A positive integer used as an internal version number. This is not shown to the users, it is used by the Android System to protect against downgrades.

versionName “1.0”

Is a string that gets shown to users and it should reflect the internal versionCode.

testInstrumentationRunner “androidx.test.runner.AndroidJUnitRunner”

This is where we set the test runner, a test runner is just a tool that Android uses to run tests. In this case we set the test runner to the AndroidJUnitRunner class which is the default test runner. It allows us to run JUnit3 and JUnit4 tests on Android devices. Just so we are not confused, AndroidJUnitRunner runs the tests and JUnit is how we write the tests.

buildTypes{…}

Inside this code block is where we define properties that Gradle uses when building and packaging the app. We can only configure build types in the module-level build.gradle file.

release{…}

This is an example of a build type in Android and it gets automatically created for us. Anything that we define inside release{...} will be specific to this build type.

minifyEnabled false

Determines if we have code shrinking enabled or not, false means we do not have it enabled. What is code shrinking? Well it is the ability to remove unused code and resources from the released build. When we push our app to production we should set this to true.

proguardFiles getDefaultProguardFile(‘proguard-android-optimize.txt’), ‘proguard-rules.pro’

Specifies the rules for compiling, by default no rules are specified. If you want to see the file where we could change the rules from default, you first need to switch to the project view inside of android studio. Then navigate to the app/proguard-rules.pro file. Notice how no rules are specified.

compileOptions{…}

In this block of code we define our compile options.

sourceCompatibility JavaVersion.VERSION_1_8

Determines the language level for the Java that we are using. In this case we have specified Java 8.

targetCompatibility JavaVersion.VERSION_1_8

The version of the generated byte code. The version that we have chosen for the byte code is also version 8.

dependencies{…}

This code block is where we tell Gradle what external libraries or internal JAR files we want to use in our project.

implementation

Using implementation is how we state what kind of dependencies we are going to use. There are a few different kind of implementations but the one that we are going to use is called a Remote Binary. The syntax for declaring a remote binary goes like this, <package-name>:<class-name>:<version-number>. Notice the similarities when comparing to this:androidx.appcompat:appcompat:1.3.0.

testImplementation

Just adds a remote Binary dependency for local tests.

androidTestImplementation

Adds a remote binary dependency only for the instrumented tests. A instrumented test is just a test that runs on a emulator or a physical device.

References

All my references can be found HERE
I added all my references to a cool little site called Ticketnote. Make sure to check them out HERE

Conclusion

Thank you for taking the time out of you day to read this blog post of mine. If you have any questions or concerns please comment below or reach out to me on Twitter.

Android (20 Part Series)

原文链接：Understanding specifics of the Android build file.

文章版权声明 1、本网站名称：拾光赋
2、本站永久网址：https://www.blogs.ink
3、本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长QQ：805375623进行删除处理。
4、本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6、本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END