阅读 428

Android封装权限管理请求框架

导读:

通过自己动手封装一个简单的Android权限管理请求框架,学习如何发布开源库到 Jitpack / Jcenter,从而激发自己的学习兴趣,以后自己也能多多造轮子,成为开源界的轮子哥。组件要求简单易懂易用,提供链式调用,因此开发组件需要相应的函数式编程思想,函数式编程在处理连续复杂逻辑的代码上有天然的优势,其风格以清晰著称,是我们封装工具类组件的不二选择。

没有接触过组件化开发的童鞋,可以先看下面这两篇文章:

  1. 什么是Android组件化和插件化?
  2. Android组件化开发入门教程

【Android权限动态请求框架】的github地址:github.com/respost/Omg… 

组件化流程:

  • 创建模块,封装自己的权限框架
  • 将开源库发布到 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<String> findDeniedPermissions(Activity activity, String... permission) {
        List<String> 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<Method> findAnnotationMethods(Class c1, Class<? extends Annotation> c2) {
        List<Method> methods = new ArrayList<>();
        for (Method method : c1.getDeclaredMethods()) {
            if (method.isAnnotationPresent(c2)) {
                methods.add(method);
            }
        }
        return methods;
    }

    public static <A extends Annotation> Method findMethodPermissionFailWithRequestCode(Class clazz, Class<A> 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 <A extends Annotation> Method findMethodWithRequestCode(Class c, Class<A> annotation, int requestCode) {
        for (Method method : c.getDeclaredMethods()) {
            if (method.isAnnotationPresent(annotation)) {
                if (isEqualRequestCodeFromAnntation(method, annotation, requestCode)) {
                    return method;
                }
            }
        }
        return null;
    }

    public static <A extends Annotation> Method findMethodPermissionSuccessWithRequestCode(Class c, Class<A> 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<String> 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<String> deniedPermissions = new ArrayList<>();
        for(int i=0; i<grantResults.length; i++){
            if(grantResults[i] != PackageManager.PERMISSION_GRANTED){
                deniedPermissions.add(permissions[i]);
            }
        }

        if(deniedPermissions.size() > 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上,如果不会的,可以参考这篇文章:blog.csdn.net/qq15577969/…

不会使用git管理项目的小白,建议把我博客里的Git栏目的文章都学习一遍!

6、项目上传到github后,在github项目界面的右侧栏点击“Create a new release” :

7、填写release的信息,如下:

8、浏览器访问Jitpack官网 ​​​​​​,在搜索栏里输入你项目的github网址,然后点击“Look up”

9、点击“Get it”进行编译,图标变成如下的绿色,表示编译成功

10、再次点击绿色的“Get it”按钮,就可以查看到开源库的依赖地址了

六、在项目中,使用我们自己的开源库

关于第三方框架(开源库)的使用方法,直接参考这篇文章,blog.csdn.net/qq15577969/…

文章分类
Android
文章标签