Import open source libraries into projects built on Android Studio

[[126313]]

Since Google released the official version of Android Studio 1.0, more and more people have started to migrate to Android Studio for development. However, many open source libraries and controls on the Internet are still developed based on Eclipse. Many people don’t know how to import them into their own Android Studio projects. Someone on Weibo sent me a private message asking me to write about it. I happened to be back early today, so I’ll write about it. I’ll mainly introduce some common scenarios for importing packages.

Preface

 --project //Project directory  
 |
 build.gradle //Gradle configuration file for the project  
 |
 settings.gradle //gradle settings will save all modules
 |
 app //module directory  
 |Configuration of __build.gradle module
 |
 module2 //module2 directory  
 |Configuration of __build.gradle module

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

 include ':app' , ':module2'  

For more information about gralde, please refer to my previous articles:

Using gradle to build android project (continued)

Building Android projects with Gradle

Importing Jar Files

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

 compile files( 'libs/name.jar' )

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

 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' ])

From the above code we can see that we can use wildcards, + represents one character, * represents 0 to more characters.

Importing Maven libraries

If the author of the open source library has put the code in 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 whether there is such an address on the github page of the open source library, or search for it in the maven library according to the package name. The project we introduced earlier is divided into three parts: group: name: version. We also follow this rule when we introduce other packages.

Import open source libraries built with gradle

This situation is rarely used, because the author of this open source library usually puts it in the Maven library, but it is occasionally used and 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 in the setting.gradle file, and then add the following code to the build.gradle file in the module that we need to depend on this module:

 compile project( ':libmodule' )

That's it.

Importing open source libraries built on Eclipse

The biggest difference between a project built based on Eclipse and a project built based on Android Studio is the directory structure.

First, we copy the module folder to our project directory, then add this module to the settings.gradle file, and then introduce the dependency in the build.gradle file of the module to be used. From this point of view, it seems that there is no difference from introducing the build based on gradle. However, there is no build.gradle file in the project built based on Eclipse, so we need to create a new one and put it under the module. The following 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, the configuration will vary depending on the respective SDK and buildtools versions, etc., as well as other factors. You can refer to my previous article.

other

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

In addition, the warehouse we imported may not be the Maven central warehouse, or it may be a warehouse we built ourselves. We can customize the warehouse address by modifying the repositories in the build.gradle file, for example:

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

In addition, the buildscript at the project level will also take effect at the module level, so there is no need to configure it in each module.

Original URL: http://blog.isming.me/2014/12/12/import-library-to-android-studio/