How to import open source libraries in android studio project

Two days ago, Google released the official version of Android Studio 1.0, and more people began to migrate to Android Studio for development. However, many open source libraries, controls, etc. on the Internet are still developed based on Eclipse in the past. Many people don’t know how to import them into their own projects based on Android Studio. Someone also sent me a private message on Weibo and asked me to write about it. It happened to be today I’m back early, so I’ll write about it. This article mainly introduces some common package guidance scenarios.

Foreword

--project //Project directory

|

build.gradle //Project’s gradle configuration file

|

settings.gradle //gradle settings, all modules will be saved

|

app //module directory

|__build.gradle module configuration

|

module2 //module2 directory

|__build.gradle module configuration

Same as eclipse The same as the projects in gradle/ Android studio builds can also have modules. Place the module under the project directory, and then add the module in settings.gradle. The easiest way is to use the folder name. For example, in our structure above, the build.gradle file should be as follows:

include ':app', ':module2'

Import Jar file

This may be very common, you can download it to others to do it well jar package, so that you can create the libs folder directly under your main module (I do this here just to be compatible with eclipse), then put the jar file into it, and then add dependecies{} in the module's build.gradle file The following code:

compile files('libs/name.jar')

When there are multiple files under the libs folder, you can use one line of code to include these packages:

compile fileTree(dir: 'libs', include: ['*.jar'])

When there are files that do not need to be included, you can do this:

compile fileTree(dir: 'libs', exclude: ['android-support *.jar'], include: ['*.jar'])

As you can see from the above code, we can use wildcards, + represents one character, and * represents 0 to more characters.

Import the library in maven

If the author of the open source library has put the code into the Maven library, we can directly introduce it in the gradle configuration, similar to the following:

compile 'com.github.dmytrodanylyk.android-process -button:library:1.0.1'

Generally, we can check if there is such an address on the github page of the open source library, or search for it based on the package name in the maven library. The project we introduced earlier is divided into three Part of group:name:version, we introduce other packages that also follow this rule.

Import the open source library built by gradle

This situation is rarely used, because the author generally puts this open source library into the maven library, but it is occasionally used and is mentioned here.

First download the file, copy the module folder of the library we need to the directory of our project, then add the folder name to the setting.gradle file, and then build in the module we need to depend on this module. Add the following code to the gradle file:

compile project(':libmodule')

That's it.

Import open source libraries built on Eclipse

The big difference between projects built based on Eclipse and projects built based on Android Studio is the different directory structure.
We first copy the module folder to our project directory, then add this module in the settings.gradle file, and then introduce dependencies in the build.gradle file in the module to be used. Looking at it this way, it seems to be based on the introduction The gradle build is no different. However, there is no build.gradle file in projects built based on Eclipse, so we need to create a new one ourselves and put it under the module. Here is a template:

apply plugin: 'android-library'
repositories {
    mavenCentral()
}
android {
    compileSdkVersion 19
    buildToolsVersion "20.0.0"
    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 19
    }
    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
            jniLibs.srcDirs = ['libs']
        }
    }
    lintOptions {
        abortOnError false
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

Of course, depending on the respective sdk and buildtools versions, etc., and others, The configuration will change, you can read my previous article.

Others

The above are the main centralized import scenarios. You can change the configuration and so on according to your actual situation.

In addition, the warehouse we import may not be the maven central warehouse, or it may be a warehouse we built ourselves. We can customize the warehouse address and just modify the repositories in the build.gradle file, for example:

buildscript {
    repositories {
        jcenter()
        mavenCentral()
        maven {
            url "https://oss.sonatype.org/content/repositories/snapshots"
        }
    }
}