Essential knowledge for Android development: I have a date with Gradle

0. Tell a story

0.1 Ant, I really thought you were an ant

I really started to get close to programming in 2012. At the end of the year, my boss said that it would take too long to manually build our app when it was released, so we should study the ant script.

At that time, I didn't even know what HashMap was, and I had almost no development experience. A small ant script really made me feel deeply that the world was full of malice. Fortunately, I later figured out what target and other weird things were, otherwise there would be no more.

0.2 Maven, do you really know how to read this word?

Maven /`meivn/

I came into contact with Maven because I read Chen Xionghua's "Spring in Action". His source code was actually built with Maven. As a result, I learned Spring in a mess, but I was able to use Maven smoothly.

Like Ant, Maven can be used to build Java projects. Like Ant, Maven's configuration is described in XML. However, Maven can manage dependencies, which allows you to "get what you want with just one sentence." For example, if I want gson, Maven says yes, just write it down and I'll get it for you when I build it later.

 <dependency>
 <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId>
 <version> 2.4 </version>
 </dependency>

You are really the boss. However, Maven is a bit difficult to learn. Many beginners get stuck when setting up the environment. Do you think it is because of the steep learning curve of Maven? Of course not. It is because the central repository of Maven was xed, so you just have to watch the "cannot resolve dependencies" every day.

Later, OSChina got close to Alibaba, and there was maven.oschina.net. When I found a job last year and was thinking about doing something, I found out that maven.oschina.net was probably locked up by Alibaba, and died for a few days, but now it is alive again. So what? Anyway, the incident of the central warehouse being hacked is a thing of the past.

0.3 Gradle, is your father Google? !

In 2013, when I excitedly told the big brother mentioned above that Maven was a good comrade, the big brother said that Google recommended using Gradle. So, I thought, Gradle, is your father Google? Or at least a godfather.

In fact, none of this matters. After all, Gradle is really easy to use. Compared with the XML configuration methods of the previous two, using code directly is definitely more flexible. Not only that, Gradle can actually use Maven warehouse to manage dependencies, just like a simplified version of Maven. If you don’t see the pom file, you would think you are still using Maven (of course, since you are using Maven’s warehouse, you naturally can’t do without Maven). Oh, you are an Ant user, that doesn’t matter, if you don’t believe it, just look:

 task helloTAS < < {
 ant.echo(message: 'Hello TAS.')
 }

1. Build with Gradle

1.1 Project Structure

As shown in the figure, this is an Android gradle project that couldn’t be more ordinary.

The settings.gradle file in the root directory is mainly used to include submodules. For example, if our project has a submodule called app, the content of settings.gradle is as follows:

 include ':app'  

·

The build.gradle file in the root directory contains some common configurations that can be used in various submodules.

·

The properties contained in the gradle.properties file will become members of the project's properties. For example, we added the property hello.

·

hello=Hello Tas!

Then we create the task in build.gradle:

 task hello < < {
 println hello
 println project.getProperties().get("hello")
 }

The output is the same:

 14:28:11: Executing external task 'hello'...
 Configuration on demand is an incubating feature.
 :app:hello
 Hello Tas!
 Hello Tas! 
 
 BUILD SUCCESSFUL 
 
 Total time: 0.54 secs
 14:28:12: External task execution finished 'hello'.

· The local.properties file is encountered in Android projects. We usually set the Android SDK and NDK paths in it. Of course, Android Studio will help us set it up. To understand this more clearly, I have extracted part of the source code of the Android Gradle plugin:

SDK.groovy, the following code mainly includes the operation of loading sdk and ndk paths.

 private void findLocation() {
 if (TEST_SDK_DIR != null) {
 androidSdkDir = TEST_SDK_DIR      
 return
 } 
 
 def rootDir = project .rootDir
 def localProperties = new File(rootDir, FN_LOCAL_PROPERTIES)
 if (localProperties.exists()) {
   Properties properties = new Properties()
   localProperties.withInputStream { instr - >   
 properties.load(instr)
 }
   def sdkDirProp = properties .getProperty('sdk.dir') 
 
 if (sdkDirProp != null) {
 androidSdkDir = new File(sdkDirProp)
 } else {
 sdkDirProp = properties .getProperty('android.dir')
        if (sdkDirProp != null) {
 androidSdkDir = new File(rootDir, sdkDirProp)
 isPlatformSdk = true  
 } else {
           throw new RuntimeException(
 "No sdk.dir property defined in local.properties file.")
 }
 } 
 
 def ndkDirProp = properties .getProperty('ndk.dir')
 if (ndkDirProp != null) {
 androidNdkDir = new File(ndkDirProp)
 }
 } else {
   String envVar = System .getenv("ANDROID_HOME")
 if (envVar != null) {
 androidSdkDir = new File(envVar)
 } else {
      String property = System .getProperty("android.home")
 if (property != null) {
 androidSdkDir = new File(property)
 }
 } 
 
 envVar = System .getenv("ANDROID_NDK_HOME")
 if (envVar != null) {
 androidNdkDir = new File(envVar)
 }
 }
 }

BasePlugin.groovy, through these two methods, we can get the paths of sdk and ndk in the gradle script

 File getSdkDirectory() {
 return sdk.sdkDirectory
 }
 File getNdkDirectory() {
 return sdk.ndkDirectory
 }

For example:

 task hello < < {
   println android.getSdkDirectory()
 }
 14:37:33: Executing external task 'hello'...
 Configuration on demand is an incubating feature
 .:app:hello
 /Users/benny/Library/Android/sdk 
 
 BUILD SUCCESSFUL
 Total time: 0.782 secs
 14:37:35: External task execution finished 'hello'.

The above is just the most common hierarchy structure. There is also a flat structure. Figure 1 is a flat structure and Figure 2 is a hierarchy structure. If you are interested, you can Google it.

1.2 Several important concepts

The order of appearance in this section is basically the same as that in build.gradle.

1.2.1 Repository and Dependency

If you are just writing Android programs, then the dependency problem may not be so annoying - but if you are writing server-side programs in Java, then it will be a lot of pain and tears.

The emergence of the repository has completely solved this problem. When developing, we only need to know the dependency ID and version. As for where it is stored, I don’t care; what it depends on, the build tool can help us find and fix it in the repository. All this is so natural. How about a latte and let the code build for a while?

It is said that in the history of Java development, many repositories have emerged, but the most popular one is of course Maven. Maven uses groupId and artifactId to lock components, and then configures the version. Then the Maven repository can finally lock a certain version of the component for you to use. For example, in the example at the beginning,

 < dependency >  
 <groupId> com.google.code.gson </groupId>​​​​    <artifactId> gson </artifactId>​​​​  
 < version > 2.4 </ version >  
 </ dependency >  

Maven can help you get gson-2.4.jar with just a few configurations. Not only that, it will also help you get javadoc and source according to your settings. Mom no longer has to worry about me not being able to see the source code of the component.

So where is this magical Maven repository? Maven Central, the central repository, is the originator of the Maven repository. Most other repositories will proxy it and add their own special repositories according to needs. Here are a few concepts:

·

Proxy warehouse: If you want to rent a house, go to Soufang.com. If you want to sign up for a driving school, I am the driving school agent. You find me and I will find the driving school. Here, there is a little difference. Once someone downloads a specific component from the proxy warehouse, the component will be cached by the proxy warehouse, and there is no need to find the proxy warehouse to download it in the future.

·

Private warehouse: Socialism with Chinese characteristics. Go your own way, why do you care about me? There are several hosted warehouses in the company's internal warehouse. These warehouses are unique to our company, and the components in them are also uploaded by our internal colleagues for team development and use.

·

Local warehouse: A hidden treasure hidden in the city. It is very similar to the proxy warehouse, except that this warehouse is stored on your own hard drive.

·

By the way, there is an extra directory under Android SDK, and many dependencies in it are also organized in the form of Maven repositories. But this is a Google feature, and they are so awesome that they don't upload to Maven's central repository. There is really nothing we can do about it.

1.2.2 SourceSets

Source code set, which mainly contains the paths of your various types of code, such as 'src/main/java' and so on.

1.2.3 Properties

As we mentioned earlier, properties are actually properties of gradle. In the gradle source code, we find the Project.java interface and see:

 /**
 * < p > Determines if this project has the given property. See < a  
 href = "#properties" > here </ a > for details of the
 * properties which are available for a project. </ p >  
 *
 * @param propertyName The name of the property to locate.
 * @return True if this project has the given property, false otherwise.
 */
 boolean hasProperty(String propertyName); 
 
 /**
 * < p > Returns the properties of this project. See < a   href = "#properties" > here </ a > for details of the properties which
 * are available for a project. </ p >   
 *
 * @return A map from property name to value.
 */
 Map < String , ?> getProperties(); 
 
 /**
 * < p > Returns the value of the given property. This method locates a property as follows: </ p >   
 *
 * < ol >   
 *
 * < li > If this project object has a property with the given name, return the value of the property. </ li >  
 *
 * < li > If this project has an extension with the given name, return the extension. </ li >  
 *
 * < li > If this project's convention object has a property with the given name, return the value of the
 * property. </ li >   
 *
 * < li > If this project has an extra property with the given name, return the value of the property. </ li >  
 *
 * < li > If this project has a task with the given name, return the task. </ li >   
 *
 * < li > Search up through this project's ancestor projects for a convention property or extra property with the
 * given name. </ li >   
 *
 * < li > If not found, a {@link MissingPropertyException} is thrown. </ li >   
 *
 * </ ol >   
 *
 * @param propertyName The name of the property.
 * @return The value of the property, possibly null.
 * @throws MissingPropertyException When the given property is unknown.
 */Object property(String propertyName) throws MissingPropertyException; 
 
 /**
 * < p > Sets a property of this project. This method searches for a property with the given name in the following
 * locations, and sets the property on the first location where it finds the property. </ p >   
 *
 * < ol >   
 *
 * < li > The project object itself. For example, the < code > rootDir </ code > project property. </ li >   
 *
 * < li > The project's {@link Convention} object. For example, the < code > srcRootName </ code > java plugin
 * property. </ li >   
 *
 * < li > The project's extra properties. </ li >   
 *
 * </ ol >   
 *
 * If the property is not found, a {@link groovy.lang.MissingPropertyException} is thrown.
 *
 *@param name The name of the property
 * @param value The value of the property
 */
 void setProperty(String name, Object value) throws MissingPropertyException;

It is not difficult to know that properties is actually a map. We can define properties in gradle.properties or through gradle scripts:

 setProperty( 'hello' , 'Hello Tas again!' )

We have already mentioned how to use it, so I won’t go into details here.

1.2.4 Project and Task

If you have used ant, then project is basically similar to ant's project tag, and task is similar to ant's target tag.

 task hello << {
 ......
 }

In fact, calling

 Task Project.task(String name) throws InvalidUserDataException;

A task is created and the behavior of the task is defined through <<. We can see that the task has the following overloads:

 Task task(String name, Closure configureClosure);

So the following definition is also legal:

 task('hello2',{
 println hello
 })

Simply put, project is a logical entity of the entire build project, and task is the specific task point of this project. For more information, please refer to the official website documentation and gradle source code.

2. Release components

To publish components, we still rely on the repository. We still take the Maven repository as an example. Most private repositories use sonatype.

2.1 UI Release

If the administrator has given you this permission, you will see the Upload Artifact tab on the UI. Select the artifact you want to upload, configure the corresponding parameters, and click Upload.

2.2 Using Maven Plugin

This means using Maven's gradle plugin to upload directly during the build process. The built artifacts need to be signed, please download GPG4WIN (windows) or GPGTOOLS (mac) to generate your own key.

Directly on the code:

gradle.properties

 sonatypeUsername = your username
 sonatypePassword = your password
 signing.keyId = your keyid
 signing.password = your keypass
 #Note that this is usually the path.
 # mac/linux
 signing.secretKeyRingFile = /Users/yourusername/.gnupg/secring.gpg 
 
 # Window XP and earlier (XP/2000/NT)
 # signing.secretKeyRingFile = C :\\Documents and Settings\\ < username > \\Application Data\\GnuPG\\secring.gpg 
 
 # Windows Vista and Windows 7
 #
 signing.secretKeyRingFile = C :\\Users\\ < username > \\AppData\\Roaming\\gnupg\\secring. 
 
 
 gpgprojectName = your artifact name
 group = your component groupid
 artifactId = your component artifactid
 # Version number, in the form of three digits. If it is an unstable version, be sure to add SNAPSHOT
 version = 0.0.1 -SNAPSHOT

build.gradle

 apply plugin: 'com.android.library'
 apply plugin: 'maven'
 apply plugin: 'signing' 
 
 android {
 compileSdkVersion 21
 buildToolsVersion "21.1.2" 
 
 defaultConfig {
 minSdkVersion 17
 targetSdkVersion 21
 versionCode 1
 versionName "0.2"
 }
 buildTypes {
 release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
 }
 }
 } 
 
 dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
 ......
 } 
 
 def isSnapshot = version .endsWith('-SNAPSHOT')
 def sonatypeRepositoryUrl
 if(isSnapshot) {
 sonatypeRepositoryUrl =
 "http://maven.oa.com/nexus/content/repositories/thirdparty-snapshots/"  
 } else {
 sonatypeRepositoryUrl = "http://maven.oa.com/nexus/content/repositories/thirdparty/"  
 } 
 
 sourceSets {
 main {
 java {
            srcDir 'src/main/java'
 }
 }
 }
 task sourcesJar(type: Jar) {
   from sourceSets.main.allSource
 classifier = 'sources'  
 } 
 
 artifacts
 //archives javadocJar
 archives sourcesJar} 
 
 signing
    if(project.hasProperty('signing.keyId') && project.hasProperty('signing.password') &&
        project.hasProperty('signing.secretKeyRingFile')) {
    sign configurations.archives
 } else {
        println "Signing information missing/incomplete for ${project.name}"
 }
 } 
 
 uploadArchives {
 repositories {
 mavenDeployer {
           if(project.hasProperty('preferedRepo') && project.hasProperty('preferedUsername')
           && project.hasProperty('preferredPassword')) { 
 
 configuration = configurations.archives​
              repository(url: preferredRepo) {
                  authentication(userName: preferredUsername, password: preferredPassword)
 }
             } else if(project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')) { 
 
                 beforeDeployment { MavenDeployment deployment - > signing.signPom(deployment) } 
 
                 repository(url: sonatypeRepositoryUrl) { authentication(userName: sonatypeUsername, password: sonatypePassword) 
 
 }
 } else {
               println "Settings sonatypeUsername/sonatypePassword missing/incomplete for ${project.name}"
 } 
 
 pom.artifactId = artifactId
 pom.project {
                   name projectName
                   packaging 'aar' 
 
                   developers {
                       developer {
                           id 'wecar'
                           name 'wecar'
 }
 }
 }
 }
 }
 }

Then run gradle uploadArchives to publish the packaged aar to the company's Maven repository. The method of jar package is similar and will not be listed here.

2.3 Using Maven Commands

This can be done by publishing the component directly in cmdline through mvn. Command instructions:

 mvn deploy:deploy-file -Durl = file ://C:\m2-repo \ -DrepositoryId = some .id \
 -Dfile = your -artifact-1.0.jar \
 [ -DpomFile = your -pom.xml] \
 [ -DgroupId = org .some.group] \
 [ -DartifactId = your -artifact] \
 [ -Dversion = 1.0 ] \
 [ -Dpackaging = jar ] \
 [ -Dclassifier = test ] \
 [ -DgeneratePom = true ] \
 [ -DgeneratePom.description = "My Project Description" ] \ [ -DrepositoryLayout = legacy ] \
 [ -DuniqueVersion = false ]

Of course, there is still an authentication problem here. We need to add it to the Maven settings configuration first:

 < servers >  
 < server >  
 < id > Maven.oa.com </ id >  
 <username> rdm </username>​​​​  
 <password> rdm </password>​​​​  
 </ server >  
 </ servers >  

Then we can upload it using the command:

 mvn deploy :deploy-file -DgroupId = com.tencent.test -DartifactId = test   
 -Dversion = 1.0.0 -Dpackaging = aar​   -Dfile = test.aar​
 -Durl = http ://maven.oa.com/nexus/content/repositories/thirdparty
 -DrepositoryId = Maven.oa.com​

3. Plugins

3.1 What is a plugin?

Plugins are actually used to make us lazy. Without plugins, if we want to build a Java project, we have to define sourceSets, classpath, build steps, etc. by ourselves.

Simply put, a plugin is actually a collection of configurations and tasks.

There are three main forms of gradle plugins:

gradle file, you can write a plugin in your build.gradle to import it directly:

 apply plugin: GreetingPlugin 
 
 class GreetingPlugin implements Plugin < Project {
   void apply(Project project) {
      project.task('hello') < < {
          println "Hello from the GreetingPlugin"
 }
 }
 }

·

The buildSrc project is a standard Groovy plug-in project under the root directory of your project. The directory is buildSrc, and you can directly reference the plug-ins written in it.

·

Independent projects are structurally the same as buildSrc projects, except that they need to be referenced by publishing to a repository. Usually, the plugins we come into contact with are in this form.

·

For details, please refer to: Chapter 61. Writing Custom Plugins

3.2 Common plugins

The plug-ins currently available are as follows:

java, build java projects

war, used to publish war packages and build web projects

groovy, build groovy projects

com.android.application, build Android app project

com.android.library, builds Android library, usually outputs aar

sign

Maven, publish to the Maven repository

org.jetbrains.intellij, build IntelliJ plugin project

3.3 Write a plugin yourself

Create a normal groovy project (it doesn't matter if it's a java project), create a src/main/groovy directory, and write the following code:

 package com.tencent.wecar.plugin 
 
 import org.gradle.api.Plugin
 import org.gradle.api.internal.project.ProjectInternal 
 
 class GreetingPlugin implements Plugin < ProjectInternal > {
    void apply(ProjectInternal project) {
       project.task('hello') < < {
 println 'hello'
 }
 }
 }

Create a META-INF/gradle-plugins directory in src/main/resources and create a greetings.properties file:

 implementation -class = com.tencent.wecar.plugin.GreetingPlugin

Where greettings is your plugin id.

build.gradle

 group 'com.tencent.wecar.plugin'
 version '1.1-SNAPSHOT'
 buildscript {
 repositories {
 mavenLocal()
 }
 } 
 
 apply plugin: 'groovy'
 apply plugin: 'java' 
 
 repositories {
 mavenCentral()
 } 
 
 sourceSets {
 main {
 groovy {
 srcDirs = [
                'src/main/groovy',
                'src/main/java'
 ]
         } // compile everything in src/ with groovy
 java { srcDirs = []}// no source dirs for the java compiler
 }
 } 
 
 dependencies {
    //tasks.withType(Compile) { options.encoding = "UTF-8" }
 compile gradleApi()
 } 
 
 // custom tasks for creating source jars
 task sourcesJar(type: Jar, dependsOn:classes) {
 classifier = 'sources'  
    from sourceSets.main.allSource
 } 
 
 // add source jar tasks as artifacts
 artifacts { archives sourcesJar } 
 
 // upload to local
 uploadArchives {
 repositories{
 mavenLocal()
 }
 }

Run uploadArchives to publish to the local repository, then you can find your own plug-in. Since no artifactId is specified, the artifactId of our plug-in is the name of our project, such as deployplugin here.

So how do we introduce this plugin?

First, add dependencies to buildScript:

 buildscript {
 repositories {
 mavenLocal()
 }
 dependencies {
        classpath 'com.tencent.wecar.plugin:deployplugin:1.1-SNAPSHOT'
 }
 }

Then:

 apply plugin: 'greetings'

In this way, our task "hello" is introduced.

4. Gradle runs slowly?

Friends who have used Gradle will feel that it is sometimes slow. We can speed up your Gradle through the following three methods.

Don't use central repository. If your repository is configured with mavenCentral, leave it alone. People all over the world are trying to abuse it, so don't get involved. Try jCenter.

· Upgrade the latest Gradle version. Currently the latest version is 2.4. Android Studio uses Gradle 2.4 by default since 1.3.

· Turn on Gradle's electric motor. In gradle.properties (look familiar? Yes, that's it!!)

Add the following configuration inside:

If your task has no timing requirements, then turning on this option can process multiple tasks concurrently and make full use of hardware resources. Well, if you have a single-core CPU. Just ignore what I said. org.gradle.parallel=true This can also be started in the command line as a parameter and is valid for 3 hours. The daemon process can greatly shorten the compilation time org.gradle.daemon=true It depends on the requirements. Gradle runs on the Java virtual machine. This specifies that the heap memory of this virtual machine is initialized to 256M and the maximum is 1G. If you only have 2G of memory, just ignore what I said. org.gradle.jvmargs=-Xms256m -Xmx1024m

Of course, the recommended way is to create a gradle.properties file under .gradle/ in your user directory to avoid pitfalls for your teammates. . .

For more information, please follow our WeChat ID: weixinBugly or search for our WeChat ID: weixinBugly.

Tencent Bugly

Bugly is an external version of Tencent's internal product quality monitoring platform, supporting the two major platforms of iOS and Android. Its main function is to monitor and report crashes and freezes that occur on the user side after the App is released, so that developers can understand the quality of the App in real time and make timely modifications. Currently, all Tencent's internal products are using it to monitor the crash of online products.

The internal team of Tencent spent 4 years to polish it. Currently, all internal products of Tencent are using it, basically covering the mobile devices and network environments in the Chinese market, and the reliability is guaranteed. When using Bugly, you use the same quality assurance method as mobile QQ, QQ Space, and Mobile Manager.