Android组件化开发实战：封装权限管理请求框架
导读：
通过自己动手封装一个简单的Android权限管理请求框架，学习如何发布开源库到 Jitpack / Jcenter，从而激发自己的学习兴趣，以后自己也能多多造轮子，成为开源界的轮子哥。组件要求简单易懂易用，提供链式调用，因此开发组件需要相应的函数式编程思想，函数式编程在处理连续复杂逻辑的代码上有天然的优势，其风格以清晰著称，是我们封装工具类组件的不二选择。
没有接触过组件化开发的童鞋，可以先看下面这两篇文章：
- Android组件化和插件化的概念
- Android组件化开发简单示例
【Android权限动态请求框架】的github地址：https://github.com/respost/OmgPermission
组件化流程：
- 创建模块，封装自己的权限框架
- 将开源库发布到
JitPack仓库
一、创建Android项目
1、打开Android Studio，创建新项目
2、选择创建空活动 “Empty Activity” → “Next” 下一步
3、填写项目名称，包名，保存路径，Language语言选择“java” → Finish
二、创建权限组件模块
1、在项目的"APP"上右键 → New → 新建一个 Module
2、 选择 Android Library → Next
3、名称填写library
三、编写关键代码
1、创建Permission.java类，这个类主要是将权限进行分组的，代码如下：
package net.zy13.library;
import android.Manifest;
import android.os.Build;
/**
* 权限类
* 将权限共分为11组，每组只要有一个权限申请成功，就默认整组权限都可以使用了。
*
* @author 安阳 QQ：15577969
* @version 1.0
* @team 美奇软件开发工作室
* @date 2020/11/23 12:54
*/
public final class Permission {
public static final String[] CALENDAR;
public static final String[] CAMERA;
public static final String[] CONTACTS;
public static final String[] LOCATION;
public static final String[] MICROPHONE;
public static final String[] PHONE;
public static final String[] SENSORS;
public static final String[] SMS;
public static final String[] STORAGE;
//安装应用权限
public static final String[] PACKAGES;
//通知栏权限
public static final String[] NOTIFICATION;
//悬浮窗权限
public static final String[] ALERTWINDOW;
//系统设置权限
public static final String[] SETTINGS;
static {
/**
* Android系统从6.0开始将权限分为一般权限和危险权限：
* 1、一般权限指不涉及用户隐私的一些权限，比如Internet权限。
* 2、危险权限指涉及获取用户隐私的一些操作所需要的权限，比如读取用户地理位置的权限。
* Android在对权限进行分类的同时，还将危险类型的权限进行了分组划分,因此我们在申请权限的时候要一组一组的申请。
*/
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
CALENDAR = new String[]{};
CAMERA = new String[]{};
CONTACTS = new String[]{};
LOCATION = new String[]{};
MICROPHONE = new String[]{};
PHONE = new String[]{};
SENSORS = new String[]{};
SMS = new String[]{};
STORAGE = new String[]{};
PACKAGES=new String[]{};
NOTIFICATION=new String[]{};
ALERTWINDOW=new String[]{};
SETTINGS=new String[]{};
} else {
CALENDAR = new String[]{
Manifest.permission.READ_CALENDAR,
Manifest.permission.WRITE_CALENDAR};
CAMERA = new String[]{
Manifest.permission.CAMERA};
CONTACTS = new String[]{
Manifest.permission.READ_CONTACTS,
Manifest.permission.WRITE_CONTACTS,
Manifest.permission.GET_ACCOUNTS};
//Android10及以上版本，新增2种权限
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
LOCATION = new String[]{
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.ACCESS_BACKGROUND_LOCATION,//在后台获取位置（Android 10.0及以上）
Manifest.permission.ACCESS_MEDIA_LOCATION//读取照片中的地理位置（Android 10.0及以上）
};
}else{
LOCATION = new String[]{
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION};
}
MICROPHONE = new String[]{
Manifest.permission.RECORD_AUDIO};
//Android8以上版本PROCESS_OUTGOING_CALLS换成了ANSWER_PHONE_CALLS。
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
PHONE = new String[]{
Manifest.permission.READ_PHONE_STATE,
Manifest.permission.CALL_PHONE,
Manifest.permission.READ_CALL_LOG,
Manifest.permission.WRITE_CALL_LOG,
Manifest.permission.USE_SIP,
Manifest.permission.ADD_VOICEMAIL,
Manifest.permission.ANSWER_PHONE_CALLS,//接听电话（Android8.0及以上）
Manifest.permission.READ_PHONE_NUMBERS//读取手机号码（Android8.0及以上）
};
}else {
PHONE = new String[]{
Manifest.permission.READ_PHONE_STATE,
Manifest.permission.CALL_PHONE,
Manifest.permission.READ_CALL_LOG,
Manifest.permission.WRITE_CALL_LOG,
Manifest.permission.USE_SIP,
Manifest.permission.ADD_VOICEMAIL,
Manifest.permission.PROCESS_OUTGOING_CALLS};
}
SENSORS = new String[]{
Manifest.permission.BODY_SENSORS,
Manifest.permission.ACTIVITY_RECOGNITION};
SMS = new String[]{
Manifest.permission.SEND_SMS,
Manifest.permission.RECEIVE_SMS,
Manifest.permission.READ_SMS,
Manifest.permission.RECEIVE_WAP_PUSH,
Manifest.permission.RECEIVE_MMS};
/**
* 外部存储权限
* Android11以上版本，存储权限统一用MANAGE_EXTERNAL_STORAGE
*/
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.R){
STORAGE = new String[]{
Manifest.permission.MANAGE_EXTERNAL_STORAGE};
}else {
STORAGE = new String[]{
Manifest.permission.READ_EXTERNAL_STORAGE,
Manifest.permission.WRITE_EXTERNAL_STORAGE};
}
//安装应用权限（Android8.0及以上）
if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
PACKAGES=new String[]{Manifest.permission.REQUEST_INSTALL_PACKAGES};
}else{
PACKAGES = new String[]{};
}
//通知栏权限
NOTIFICATION=new String[]{Manifest.permission.ACCESS_NOTIFICATION_POLICY};
//悬浮窗权限
ALERTWINDOW=new String[]{Manifest.permission.SYSTEM_ALERT_WINDOW};
//系统设置权限
SETTINGS=new String[]{Manifest.permission.WRITE_SETTINGS};
}
}
}
2、创建PermissionUtils.java工具类，这个类主要是封装一些权限的通用方法，代码如下：
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Build;
import androidx.fragment.app.Fragment;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
/**
* 权限的工具类
*
* @author 安阳 QQ：15577969
* @version 1.0
* @team 美奇软件开发工作室
* @date 2020/11/23 13:09
*/
public class PermissionUtils {
/**
* 判断Android系统版本是否大于6.0
*
* @return
*/
public static boolean judgeVersion() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
}
/**
* 从申请的权限中找出未授予的权限
*
* @param activity
* @param permission
* @return
*/
@TargetApi(value = Build.VERSION_CODES.M)
public static List findDeniedPermissions(Activity activity, String... permission) {
List denyPermissions = new ArrayList<>();
for (String value : permission) {
if (activity.checkSelfPermission(value) != PackageManager.PERMISSION_GRANTED) {
denyPermissions.add(value);
}
}
return denyPermissions;
}
/**
* 寻找相应的注解方法
*
* @param c1 要寻找的那个类
* @param c2 响应的注解标记
* @return
*/
public static List findAnnotationMethods(Class c1, Class c2) {
List methods = new ArrayList<>();
for (Method method : c1.getDeclaredMethods()) {
if (method.isAnnotationPresent(c2)) {
methods.add(method);
}
}
return methods;
}
public static Method findMethodPermissionFailWithRequestCode(Class clazz, Class permissionFailClass, int requestCode) {
for (Method method : clazz.getDeclaredMethods()) {
if (method.isAnnotationPresent(permissionFailClass)) {
if (requestCode == method.getAnnotation(PermissionFail.class).requestCode()) {
return method;
}
}
}
return null;
}
/**
* 找到相应的注解方法（requestCode请求码与需要的一样）
*
* @param m
* @param c
* @param requestCode
* @return
*/
public static boolean isEqualRequestCodeFromAnntation(Method m, Class c, int requestCode) {
if (c.equals(PermissionFail.class)) {
return requestCode == m.getAnnotation(PermissionFail.class).requestCode();
} else if (c.equals(PermissionSuccess.class)) {
return requestCode == m.getAnnotation(PermissionSuccess.class).requestCode();
} else {
return false;
}
}
public static Method findMethodWithRequestCode(Class c, Class annotation, int requestCode) {
for (Method method : c.getDeclaredMethods()) {
if (method.isAnnotationPresent(annotation)) {
if (isEqualRequestCodeFromAnntation(method, annotation, requestCode)) {
return method;
}
}
}
return null;
}
public static Method findMethodPermissionSuccessWithRequestCode(Class c, Class permissionFailClass, int requestCode) {
for (Method method : c.getDeclaredMethods()) {
if (method.isAnnotationPresent(permissionFailClass)) {
if (requestCode == method.getAnnotation(PermissionSuccess.class).requestCode()) {
return method;
}
}
}
return null;
}
public static Activity getActivity(Object object) {
if (object instanceof Fragment) {
return ((Fragment) object).getActivity();
} else if (object instanceof Activity) {
return (Activity) object;
}
return null;
}
} 3、创建成功和失败的回调接口类，代码如下：
PermissionSuccess.java
/**
* @author 安阳 QQ：15577969
* @version 1.0
* @team 美奇软件开发工作室
* @date 2020/11/23 13:12
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PermissionSuccess {
int requestCode();
}PermissionFail.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 安阳 QQ：15577969
* @version 1.0
* @team 美奇软件开发工作室
* @date 2020/11/23 13:12
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionFail {
int requestCode();
}4、创建OmgPermission.java对象类，这个类就是我们封装的权限框架主体，代码如下：
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Build;
import androidx.fragment.app.Fragment;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
/**
* 动态权限的对象
* @author 安阳 QQ：15577969
* @version 1.0
* @team 美奇软件开发工作室
* @date 2020/11/23 12:56
*/
public class OmgPermission {
//权限集合
private String[] mPermissions;
//请求码
private int mRequestCode;
//对象
private Object object;
//权限回调方法
private static PermissionCallback permissionCallback;
/**
* 构造方法
*/
private OmgPermission(Object object) {
this.object = object;
}
/**
* with函数是将某对象作为函数的参数，在函数块内可以通过 this 指代该对象。
* 返回值为函数块的最后一行或指定return表达式。
*/
public static OmgPermission with(Activity activity){
return new OmgPermission(activity);
}
public static OmgPermission with(Fragment fragment){
return new OmgPermission(fragment);
}
/**
* 获取权限组集合
* @param permissions
* @return
*/
public OmgPermission permissions(String... permissions){
this.mPermissions = permissions;
return this;
}
/**
* 添加请求码
* @param requestCode
* @return
*/
public OmgPermission addRequestCode(int requestCode){
this.mRequestCode = requestCode;
return this;
}
@TargetApi(value = Build.VERSION_CODES.M)
public void request(){
permissionCallback = null;
requestPermissions(object, mRequestCode, mPermissions);
}
@TargetApi(value = Build.VERSION_CODES.M)
public void request(PermissionCallback callback){
if(callback!=null) {
permissionCallback = callback;
}
requestPermissions(object, mRequestCode, mPermissions);
}
/**
* 活动请求权限
* @param activity
* @param requestCode
* @param permissions
*/
public static void needPermission(Activity activity, int requestCode, String[] permissions){
permissionCallback = null;
requestPermissions(activity, requestCode, permissions);
}
public static void needPermission(Activity activity, int requestCode, String permission){
permissionCallback = null;
needPermission(activity, requestCode, new String[] { permission });
}
/**
* 活动请求权限，带回调方法
* @param activity
* @param requestCode
* @param permissions
* @param callback
*/
public static void needPermission(Activity activity, int requestCode, String[] permissions
,OmgPermission.PermissionCallback callback) {
if (callback != null) {
permissionCallback = callback;
}
requestPermissions(activity, requestCode, permissions);
}
public static void needPermission(Activity activity, int requestCode, String permission,PermissionCallback callback){
if (callback != null) {
permissionCallback = callback;
}
needPermission(activity, requestCode, new String[] { permission });
}
/**
* 碎片请求权限
* @param fragment
* @param requestCode
* @param permissions
*/
public static void needPermission(Fragment fragment, int requestCode, String[] permissions){
permissionCallback = null;
requestPermissions(fragment, requestCode, permissions);
}
public static void needPermission(Fragment fragment, int requestCode, String permission){
permissionCallback = null;
needPermission(fragment, requestCode, new String[] { permission });
}
/**
* 碎片请求权限，带回调方法
* @param fragment
* @param requestCode
* @param permissions
* @param callback
*/
public static void needPermission(Fragment fragment, int requestCode, String[] permissions
,OmgPermission.PermissionCallback callback) {
if (callback != null) {
permissionCallback = callback;
}
requestPermissions(fragment, requestCode, permissions);
}
public static void needPermission(Fragment fragment, int requestCode, String permission,PermissionCallback callback){
if (callback != null) {
permissionCallback = callback;
}
needPermission(fragment, requestCode, new String[] { permission });
}
/**
* 请求权限
* @param object
* @param requestCode
* @param permissions
*/
@TargetApi(value = Build.VERSION_CODES.M)
private static void requestPermissions(Object object, int requestCode, String[] permissions){
//判断系统版本是否大于6.0
if(!PermissionUtils.judgeVersion()) {
if (permissionCallback != null) {
permissionCallback.permissionSuccess(requestCode);
}else {
doExecuteSuccess(object, requestCode);
}
return;
}
List deniedPermissions = PermissionUtils.findDeniedPermissions(PermissionUtils.getActivity(object), permissions);
/**
* 先检查是否有没有授予的权限，有的话请求，没有的话就直接执行权限授予成功的接口/注解方法
*/
if(deniedPermissions.size() > 0){
if(object instanceof Activity){
((Activity)object).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
} else if(object instanceof Fragment){
((Fragment)object).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
} else {
throw new IllegalArgumentException(object.getClass().getName() + " is not supported");
}
} else {
if (permissionCallback != null) {
permissionCallback.permissionSuccess(requestCode);
}else {
doExecuteSuccess(object, requestCode);
}
}
}
private static void doExecuteSuccess(Object activity, int requestCode) {
Method executeMethod = PermissionUtils.findMethodWithRequestCode(activity.getClass(),
PermissionSuccess.class, requestCode);
executeMethod(activity, executeMethod);
}
private static void doExecuteFail(Object activity, int requestCode) {
Method executeMethod = PermissionUtils.findMethodWithRequestCode(activity.getClass(),
PermissionFail.class, requestCode);
executeMethod(activity, executeMethod);
}
private static void executeMethod(Object activity, Method executeMethod) {
if(executeMethod != null){
try {
if(!executeMethod.isAccessible()) executeMethod.setAccessible(true);
executeMethod.invoke(activity, new Object[]{});
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
public static void onRequestPermissionsResult(Activity activity, int requestCode, String[] permissions,
int[] grantResults) {
requestResult(activity, requestCode, permissions, grantResults);
}
public static void onRequestPermissionsResult(Fragment fragment, int requestCode, String[] permissions,
int[] grantResults) {
requestResult(fragment, requestCode, permissions, grantResults);
}
/**
* 回调接口不为空的话，先执行回调接口的方法，若为空，则寻找响应的注解方法。
* @param obj
* @param requestCode
* @param permissions
* @param grantResults
*/
private static void requestResult(Object obj, int requestCode, String[] permissions,
int[] grantResults){
List deniedPermissions = new ArrayList<>();
for(int i=0; i 0){
if(permissionCallback!=null){
permissionCallback.permissionFail(requestCode);
}else {
doExecuteFail(obj, requestCode);
}
} else {
if(permissionCallback!=null){
permissionCallback.permissionSuccess(requestCode);
}else {
doExecuteSuccess(obj, requestCode);
}
}
}
public interface PermissionCallback{
//请求权限成功
void permissionSuccess(int requsetCode);
//请求权限失败
void permissionFail(int requestCode);
}
}
四、本地调用权限框架
1、添加依赖，在主项目的build.gradle文件的dependencies{}配置里，添加如下语句：
dependencies {
//集成权限请求框架
implementation project(':library')
}2、简单示例用法：
public class MainActivity extends AppCompatActivity {
//联系人请求码
private final int REQUEST_CONTACT = 100;
//存储请求码
private final int REQUEST_STORAGE = 200;
//相机请求码
private final int REQUEST_CAMERA = 300;
private Button storageButton;
private Button cameraButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
/**
* 请求权限
* request()方法的参数可以有也可以没有，有且不为空，就会回调PermissionCallback的响应的回调方法，没有或为空，则回调响应的注解方法。
*/
OmgPermission.with(MainActivity.this)
//添加请求码
.addRequestCode(REQUEST_CAMERA)
//单独申请一个权限
//.permissions(Manifest.permission.CAMERA)
//同时申请多个权限
.permissions(Manifest.permission.READ_CONTACTS, Manifest.permission.RECEIVE_SMS, Manifest.permission.WRITE_CONTACTS)
.request(new OmgPermission.PermissionCallback(){
@Override
public void permissionSuccess(int requestCode) {
Toast.makeText(MainActivity.this, "成功授予联系人权限，请求码： " + requestCode, Toast.LENGTH_SHORT).show();
}
@Override
public void permissionFail(int requestCode) {
Toast.makeText(MainActivity.this, "授予联系人权限失败，请求码： " + requestCode, Toast.LENGTH_SHORT).show();
}
});
}
/**
* 回调注解方法
* 当request()没有参数的时候，就会在当前类里面寻找相应的注解方法
*/
@PermissionSuccess(requestCode = REQUEST_STORAGE)
public void permissionSuccess() {
Toast.makeText(MainActivity.this, "回调注解方法：成功授予读写权限" , Toast.LENGTH_SHORT).show();
}
@PermissionFail(requestCode = REQUEST_STORAGE)
public void permissionFail() {
Toast.makeText(MainActivity.this, "回调注解方法：授予读写权限失败" , Toast.LENGTH_SHORT).show();
}
@PermissionSuccess(requestCode = REQUEST_CONTACT)
public void permissionSuccessContact() {
Toast.makeText(MainActivity.this, "回调注解方法：成功授予联系人权限" , Toast.LENGTH_SHORT).show();
}
@PermissionFail(requestCode = REQUEST_CONTACT)
public void permissionFailContact() {
Toast.makeText(MainActivity.this, "回调注解方法：授予联系人权限失败" , Toast.LENGTH_SHORT).show();
}
@PermissionSuccess(requestCode = REQUEST_CAMERA)
public void permissionSuccessCamera() {
Toast.makeText(MainActivity.this, "回调注解方法：成功授予相机权限" , Toast.LENGTH_SHORT).show();
}
@PermissionFail(requestCode = REQUEST_CAMERA)
public void permissionFailCamera() {
Toast.makeText(MainActivity.this, "回调注解方法：授予相机权限失败" , Toast.LENGTH_SHORT).show();
}
/**
* 申请权限的系统回调方法
* @param requestCode
* @param permissions
* @param grantResults
*/
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
OmgPermission.onRequestPermissionsResult(MainActivity.this, requestCode, permissions, grantResults);
}
}3、点击按钮时，使用needPermission()方法动态申请权限：
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
//联系人请求码
private final int REQUEST_CONTACT = 100;
//存储请求码
private final int REQUEST_STORAGE = 200;
//相机请求码
private final int REQUEST_CAMERA = 300;
private Button storageButton;
private Button cameraButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//获取控件
storageButton=(Button) findViewById(R.id.storageButton);
cameraButton=(Button) findViewById(R.id.cameraButton);
//设置监听
storageButton.setOnClickListener(this);
cameraButton.setOnClickListener(this);
}
@Override
public void onClick(View view) {
switch (view.getId()){
//申请存储权限按钮
case R.id.storageButton:
/**
* 请求权限
* 如果没有callback作为参数，就会去调用响应的注解方法
*/
OmgPermission.needPermission(MainActivity.this, REQUEST_STORAGE, Permission.STORAGE);
break;
//申请相机权限按钮
case R.id.cameraButton:
/**
* 请求权限
*/
OmgPermission.needPermission(MainActivity.this, REQUEST_CAMERA, Permission.CAMERA,new OmgPermission.PermissionCallback(){
@Override
public void permissionSuccess(int requestCode) {
Toast.makeText(MainActivity.this, "成功授予相机权限", Toast.LENGTH_SHORT).show();
}
@Override
public void permissionFail(int requestCode) {
Toast.makeText(MainActivity.this, "授予相机权限失败", Toast.LENGTH_SHORT).show();
}
});
break;
}
}
}
五、发布开源库到 JitPack
JitPack的简介：
JitPack实际上是一个自定义的Maven仓库，不过它的流程极度简化，只需要输入Github项目地址就可发布项目，大大方便了像我这种懒得配置环境的人。JitPack允许你把git 托管的项目（支持github和码云），轻松发布到 jitpack的 maven 仓库上，它所有内容都通过内容分发网络（CDN）使用加密 https 连接获取！
1、在项目的build.gradle（project级别）文件配置里，添加 maven的地址和github插件依赖：
buildscript {
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.5.2'
//添加maven的github插件
classpath 'com.github.dcendents:android-maven-gradle-plugin:2.0'
}
}
allprojects {
repositories {
google()
jcenter()
//maven地址
maven { url "https://jitpack.io" }
}
}我这里用的JitPack插件版本是2.0，因为我的Gradle版本是3.5.2，对应的JitPack是2.0，如果你的Gradle版本比较高或者比较低，需要自己查询JitPack对应的版本号
2、在 library模块的 build.gradle下 apply 插件和添加 group分组：
apply plugin: 'com.android.library'
//----------------------maven插件 start---------------------//
//apply maven插件
apply plugin: 'com.github.dcendents.android-maven'
//定义github分组，这里的respost改为你github的账号名
group='com.github.respost'
//----------------------maven插件 end ---------------------//
android {
}3、添加好后保存设置，然后点击提示信息里的“Sync Now”进行项目同步。
4、在命令行中输入 gradlew install ，从而构建你的 library 到你的本地 maven 仓库
等待出现 BUILD SUCCESSFUL 就表示构建成功了。若 出现 BUILD FAIL，说明构建失败，这时候你就要按照失败提示去排错，排错完后在执行一遍 gradlew install 命令，直到出现 BUILD SUCCESSFUL
5、上传项目到github上，如果不会的，可以参考这篇文章：https://blog.csdn.net/qq15577969/article/details/107607507
不会使用
git管理项目的小白，建议把我博客里的Git栏目的文章都学习一遍！
6、项目上传到github后，在github项目界面的右侧栏点击“Create a new release” ：
7、填写release的信息，如下：
8、浏览器访问Jitpack官网 ，在搜索栏里输入你项目的github网址，然后点击“Look up”
9、点击“Get it”进行编译，图标变成如下的绿色，表示编译成功
10、再次点击绿色的“Get it”按钮，就可以查看到开源库的依赖地址了
六、在项目中，使用我们自己的开源库
关于第三方框架（开源库）的使用方法，直接参考这篇文章，https://blog.csdn.net/qq15577969/article/details/109515808