Android 6.0权限判断封装的基类 实用在activity和fragment中

使用在activity中


package com.shengdacar.shengdachexian1.base;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.ContextCompat;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

import com.google.gson.Gson;
import com.shengdacar.shengdachexian1.R;
import com.shengdacar.shengdachexian1.utils.CustomProgressDialog;
import com.shengdacar.shengdachexian1.utils.DeveiceUtils;
import com.shengdacar.shengdachexian1.utils.L;
import com.shengdacar.shengdachexian1.utils.NetUtils;

import java.util.ArrayList;
import java.util.List;


/**
 * create by huyi
 */
@SuppressWarnings("unused")
public abstract class BaseActivity extends FragmentActivity {
    public CustomProgressDialog progressDialog = null;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initViews();
        init();
        setTranslucentStatus();
    }

    public void setTranslucentStatus() {
        DeveiceUtils.setTranslucentStatus(this);
    }

    public void isNet(){
        if (!NetUtils.isNetworkAvailable(this)) {
            NetUtils.showDialog(this);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        isNet();
        getResources();
    }
    protected abstract void initViews();

    protected abstract void init();

    /**
     * 添加一个fragment到指定的view container中
     * 无动画延迟
     */
    public void addFragment(Fragment fragment, Boolean isBack, int res) {
        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        L.d("switch content and name is " + fragment.getClass().getSimpleName());
        if(!fragment.isAdded()){
            ft.replace(res, fragment, fragment.getClass().getSimpleName());
        }
        if (isBack) {
            ft.addToBackStack(null);//添加到返回栈
        }
        ft.commitAllowingStateLoss(); // 防止 Can not perform this action after

    }

    public void switchFragment(Fragment to, Boolean isBack, int resId) {
        if (to.isVisible()) {
            return;
        }
        FragmentManager fm = getSupportFragmentManager();
        FragmentTransaction ft = fm.beginTransaction();
        Fragment from = fm.findFragmentById(resId);
        ft.setCustomAnimations(
                R.anim.slide_left_in,
                R.anim.slide_left_out,
                R.anim.slide_right_out,
                R.anim.slide_right_in);
        if (from != null) {
            ft.hide(from);
        }
        if (to.isAdded()) {
            ft.show(to);
        } else {
            ft.add(resId, to, to.getClass().getSimpleName());
            if (isBack) {
                ft.addToBackStack(null);
            }
        }
        ft.commitAllowingStateLoss();
    }

    /**
     * 显示loading
     */

    public void startProgressDialog() {
        try {
            if (progressDialog == null) {
                progressDialog = CustomProgressDialog.createDialog(this);
            }
            progressDialog.setCanceledOnTouchOutside(false);// 设置点击外面dialog不消失
            progressDialog.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 设置按返回键dialog是否小时消失
     * @param f    false不消失  true消失
     */
    public void setDialogCancelable(boolean f){
        progressDialog.setCancelable(f);
    }
    /**
     * 取消loading显示
     */
    public void stopProgressDialog() {
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
    }

    /**
     *
     *隐藏软键盘
     */
    public void hideSoftWindow(){
        InputMethodManager inputMethodManager =
                (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(
                getWindow().getDecorView().getWindowToken(), 0);
    }

    @Override
    public void onBackPressed() {
        hideSoftWindow();
        super.onBackPressed();
    }

    /**
     * 设置 app 不随着系统字体的调整而变化
     */
    @Override
    public Resources getResources() {
        Resources res = super.getResources();
        Configuration config=new Configuration();
        //config.setToDefaults();
        config.fontScale=1.0f;
        res.updateConfiguration(config, res.getDisplayMetrics());
        return res;
    }


    /**
     * 23版本对权限的判断
     */
    private final String TAG = "MPermissions";
    private int REQUEST_CODE_PERMISSION = 0x00099;
    private Object REQUEST_RESPONE_PERMISSION;

    /**
     * 请求权限
     *
     * @param permissions 请求的权限
     * @param requestCode 请求权限的请求码
     */
    public void requestPermission(String[] permissions, int requestCode ,Object respone) {
        this.REQUEST_CODE_PERMISSION = requestCode;
        this.REQUEST_RESPONE_PERMISSION = respone;
        if (checkPermissions(permissions)) {
            permissionSuccess(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
        } else {
            List<String> needPermissions = getDeniedPermissions(permissions);
            ActivityCompat.requestPermissions(this, needPermissions.toArray(new String[needPermissions.size()]), REQUEST_CODE_PERMISSION);
        }
    }

    /**
     * 检测所有的权限是否都已授权
     *
     * @param permissions
     * @return
     */
    private boolean checkPermissions(String[] permissions) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            return true;
        }

        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(this, permission) !=
                    PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 获取权限集中需要申请权限的列表
     *
     * @param permissions
     * @return
     */
    private List<String> getDeniedPermissions(String[] permissions) {
        List<String> needRequestPermissionList = new ArrayList<>();
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(this, permission) !=
                    PackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
                needRequestPermissionList.add(permission);
            }
        }
        return needRequestPermissionList;
    }


    /**
     * 系统请求权限回调
     *
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_CODE_PERMISSION) {
            if (verifyPermissions(grantResults)) {
                permissionSuccess(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
            } else {
                permissionFail(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
                showTipsDialog();
            }
        }
    }

    /**
     * 确认所有的权限是否都已授权
     *
     * @param grantResults
     * @return
     */
    private boolean verifyPermissions(int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 显示提示对话框
     */
    private void showTipsDialog() {
        new AlertDialog.Builder(this)
                .setTitle("提示信息")
                .setMessage("当前应用缺少必要权限,该功能暂时无法使用。如若需要,请单击【确定】按钮前往设置中心进行权限授权。")
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                    }
                })
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        startAppSettings();
                    }
                }).show();
    }

    /**
     * 启动当前应用设置页面
     */
    private void startAppSettings() {
        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        intent.setData(Uri.parse("package:" + getPackageName()));
        startActivity(intent);
    }

    /**
     * 获取权限成功
     *
     * @param requestCode
     */
    public void permissionSuccess(int requestCode,Object respone) {
        L.d(TAG, "获取权限成功=" + requestCode);
        L.d(TAG, "获取的响应类=" + new Gson().toJson(respone));
    }

    /**
     * 权限获取失败
     * @param requestCode
     */
    public void permissionFail(int requestCode,Object respone) {
        L.d(TAG, "获取权限失败=" + requestCode);
        L.d(TAG, "获取的响应类=" + new Gson().toJson(respone));
    }

    /**
     * 点击空白区域隐藏软键盘
     * @param ev
     * @return
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        // TODO Auto-generated method stub
        if(ev.getAction() == MotionEvent.ACTION_DOWN) {
            View view =getCurrentFocus();
            if(isHideInput(view, ev)) {
                HideSoftInput(view.getWindowToken());
            }
        }
        return super.dispatchTouchEvent(ev);
    }
    // 判定是否需要隐藏
    private boolean isHideInput(View v, MotionEvent ev) {
        if(v != null && (v instanceof EditText)) {
            int[] l = {0, 0};
            v.getLocationInWindow(l);
            int left = l[0], top = l[1], bottom = top + v.getHeight(), right = left
                    + v.getWidth();
            if(ev.getX() > left && ev.getX() < right && ev.getY() > top
                    && ev.getY() < bottom) {
                return false;
            }else {
                return true;
            }
        }
        return false;
    }
    // 隐藏软键盘
    private void HideSoftInput(IBinder token) {
        if(token != null) {
            InputMethodManager manager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
            manager.hideSoftInputFromWindow(token,
                    InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }
}
 



使用在fragment中

package com.shengdacar.shengdachexian1.base;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;

import com.google.gson.Gson;
import com.shengdacar.shengdachexian1.utils.CustomProgressDialog;
import com.shengdacar.shengdachexian1.utils.L;
import com.shengdacar.shengdachexian1.utils.NetUtils;

import java.util.ArrayList;
import java.util.List;


/**
 * fragment的基类
 *
 * @author zhangyalin
 */
public abstract class BaseFragment extends Fragment implements OnClickListener {

    private CustomProgressDialog progressDialog;

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        if (!NetUtils.isNetworkAvailable(getActivity())) {
            NetUtils.showDialog(getActivity());
        }
    }



    // 开始进度条
    public void startProgressDialog(Context context) {
        try {
            if (progressDialog == null) {
                progressDialog = CustomProgressDialog.createDialog(context);
                progressDialog.setCanceledOnTouchOutside(false);// 设置点击外面dialog不消失
            }
            progressDialog.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //禁止返回键取消对话框
    public void setDialogCancelable(boolean f){
        progressDialog.setCancelable(f);
    }

    //取消显示loading
    public void stopProgressDialog() {
        if (progressDialog != null) {
            progressDialog.dismiss();
            progressDialog = null;
        }
    }


    /**
     * 23版本对权限的判断
     */
    private final String TAG = "MPermissions";
    private int REQUEST_CODE_PERMISSION = 0x00099;
    private Object REQUEST_RESPONE_PERMISSION;
    /**
     * 请求权限
     *
     * @param permissions 请求的权限
     * @param requestCode 请求权限的请求码
     * @param respone 接口返回的响应类
     */
    public void requestPermission(String[] permissions, int requestCode,Object respone) {
        this.REQUEST_CODE_PERMISSION = requestCode;
        this.REQUEST_RESPONE_PERMISSION = respone;
        if (checkPermissions(permissions)) {
            permissionSuccess(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
        } else {
            List<String> needPermissions = getDeniedPermissions(permissions);
            requestPermissions( needPermissions.toArray(new String[needPermissions.size()]), REQUEST_CODE_PERMISSION);
        }
    }

    /**
     * 检测所有的权限是否都已授权
     *
     * @param permissions
     * @return
     */
    private boolean checkPermissions(String[] permissions) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            return true;
        }

        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(getActivity(), permission) !=
                    PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 获取权限集中需要申请权限的列表
     *
     * @param permissions
     * @return
     */
    private List<String> getDeniedPermissions(String[] permissions) {
        List<String> needRequestPermissionList = new ArrayList<>();
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(getActivity(), permission) !=
                    PackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), permission)) {
                needRequestPermissionList.add(permission);
            }
        }
        return needRequestPermissionList;
    }


    /**
     * 系统请求权限回调
     *
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_CODE_PERMISSION) {
            if (verifyPermissions(grantResults)) {
                permissionSuccess(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
            } else {
                permissionFail(REQUEST_CODE_PERMISSION,REQUEST_RESPONE_PERMISSION);
                showTipsDialog();
            }
        }
    }

    /**
     * 确认所有的权限是否都已授权
     *
     * @param grantResults
     * @return
     */
    private boolean verifyPermissions(int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 显示提示对话框
     */
    private void showTipsDialog() {
        new AlertDialog.Builder(getActivity())
                .setTitle("提示信息")
                .setMessage("当前应用缺少必要权限,该功能暂时无法使用。如若需要,请单击【确定】按钮前往设置中心进行权限授权。")
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                    }
                })
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        startAppSettings();
                    }
                }).show();
    }

    /**
     * 启动当前应用设置页面
     */
    private void startAppSettings() {
        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        intent.setData(Uri.parse("package:" + getActivity().getPackageName()));
        startActivity(intent);
    }
    /**
     * 获取权限成功
     *
     * @param requestCode
     */
    public void permissionSuccess(int requestCode,Object respone) {
        L.d(TAG, "获取权限成功=" + requestCode);
        L.d(TAG, "获取的响应类=" + new Gson().toJson(respone));
    }

    /**
     * 权限获取失败
     * @param requestCode
     */
    public void permissionFail(int requestCode,Object respone) {
        L.d(TAG, "获取权限失败=" + requestCode);
        L.d(TAG, "获取的响应类=" + new Gson().toJson(respone));
    }


    /**
     * 某个布局带动效展开
     * @param v
     * @param height
     */
    public void animateOpen(View v,int height) {
        v.setVisibility(View.VISIBLE);
        ValueAnimator animator = createDropAnimator(v, 0,
                height);
        animator.setDuration(200);
        animator.start();

    }
    /**
     * 某个布局带动效收起
     * @param view
     * @param origHeight
     */
    public void animateClose(final View view,int origHeight) {
        ValueAnimator animator = createDropAnimator(view, origHeight, 0);
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                view.setVisibility(View.GONE);
            }

        });
        animator.setDuration(200);
        animator.start();
    }

    /**
     * 创建值动画
     * @param v
     * @param start
     * @param end
     * @return
     */

    private ValueAnimator createDropAnimator(final View v, int start, int end) {
        ValueAnimator animator = ValueAnimator.ofInt(start, end);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                int value = (int) animation.getAnimatedValue();
                ViewGroup.LayoutParams layoutParams = v.getLayoutParams();
                layoutParams.height = value;//从上到下展示
               // layoutParams.width = value;//从左到右展示
                v.setLayoutParams(layoutParams);
            }
        });
        return animator;
    }


    /**
     * View渐隐动画效果
     */
    public  void HideAnimation(final View view, int duration)
    {
        ValueAnimator animator=createAnimator(view,1.0f,0.0f);
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                view.setVisibility(View.GONE);
            }
        });
        animator.setDuration(duration);
        animator.start();
    }
    /**
     * View渐现动画效果
     */
    public  void ShowAnimation( final View view, int duration)
    {
        view.setVisibility(View.VISIBLE);
        ValueAnimator animator=createAnimator(view,0.0f,1.0f);
        animator.setDuration(duration);
        animator.start();
    }

    /**
     * 创建值动画
     * @param v
     * @param start
     * @param end
     * @return
     */

    private ValueAnimator createAnimator(final View v,float start,float end) {
        ValueAnimator animator = ValueAnimator.ofFloat(start,end);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value = (float) animation.getAnimatedValue();
                v.setAlpha(value);
            }
        });

        return animator;

    }
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值