App下载 微信公众号

BaseActivity基类设计【Android】

技术 · 移动开发 · Android/ 作者【吾非言】/ 发布于2018-3-5/ 1.73k次浏览
2018 3/5 9:1
摘要： BaseActivity基类基本上每一个移动端开发者都会进行编写的一个类，那么到底如何设计BaseActivity基类才算是一个合理的，优秀的基类呢？BaseActivity基类到底可以实现什么呢？本篇文章将会给大家进行最好的讲解。

精辟句：上帝给你关上一扇门，总会为你在墙上留下很多开锁的电话号码。

伴职创作

通常在APP开发当中都会自定义一个抽象的BaseActivity，用作Acitvity的基类，主要是用来实现Activity的一些公共属性以及公共方法。一个优秀的BaseActivity，在一定程度上能够优化代码结构，降低耦合度，提高代码可读性，方便修改。

一般情况下BaseActivity，只会将Activity的一些公共部分进行集成，这也是设计BaseActivity基类其中一个准则。当然BaseActivity的设计还取决于当前应用要求。那么如何去设计BaseActivity基类呢？首先要明白BaseActivity基类能够做些什么。

一、隐藏标题栏

在Android开发中，隐藏标题栏的方式有很多，例如可以在style.xml中，设置当前应用的主题，如下：

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        ......
        <!--无主题-->
        <item name="windowNoTitle">true</item>
    </style>

</resources>

通过BaseActivity同样可以进行设置，通常设置无标题主题是在Activity的onCreate方法中进行设置。不过这里设置是要分情况的。

1、如果定义的BaseActivity是继承android.support.v7.app.AppCompatActivity，需要通过以下方法进行设置：

// 隐藏标题栏
if (getSupportActionBar() != null)
        getSupportActionBar().hide();

2、如果定义的BaseActivity是继承android.app.Activity或者android.support.v4.app.FragmentActivity，需要通过以下方法进行设置：

// 隐藏标题栏
requestWindowFeature(Window.FEATURE_NO_TITLE);

二、状态栏沉浸效果

状态栏沉浸效果设置方式也有很多种，例如可以在也是在style.xml中，设置当前应用的主题，如下：

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        ......
        <!--沉浸效果-->
        <item name="android:fitsSystemWindows">true</item>
    </style>

</resources>

通过BaseActivity同样可以进行设置，通常设置无标题主题是在Activity的onCreate方法中进行设置。如下：

// 沉浸效果
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // 透明状态栏
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
        // 透明导航栏
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
}

三、定义Activity管理类

为什么要设置Activity管理类呢？打个简单的例子，当程序退出的时候，是不是要把所有打开的Activity进行关闭，也就是清空堆栈。如果不设置Activity管理类根本就知不知道到底打开了多少个Activity。例如定义一个名为ActivityUtil的管理类，代码如下：

/**
 * Activity工具类
 *
 * @author 邹峰立
 */
public class ActivityUtil {
    private List<Activity> activityList;
    private static ActivityUtil instance;
    private boolean removeAllKeepALock = false;

    // 单例模式
    public static ActivityUtil getInstance() {
        if (null == instance) {
            synchronized (ActivityUtil.class) {
                instance = new ActivityUtil();
            }
        }
        return instance;
    }

    // 初始化activityList
    private List<Activity> initActivityList() {
        if (activityList == null)
            activityList = Collections.synchronizedList(new ArrayList<Activity>());
        return activityList;
    }

    // 添加Activity到容器中
    public synchronized void addActivity(Activity activity) {
        initActivityList().add(activity);
    }

    // 移除Activity
    public synchronized void removeActivity(Activity activity) {
        if (activityList != null)
            activityList.remove(activity);
    }

    // 保存Activity不变移除其他Activity
    public synchronized void removeAllKeepA(Activity activity) {
        if (!removeAllKeepALock && activityList != null && activityList.size() > 0) {
            removeAllKeepALock = true;
            Iterator<Activity> iterator = activityList.iterator();
            while (iterator.hasNext()) {
                Activity activity1 = iterator.next();
                if (activity1 != null
                        && activity != null
                        && !activity.getComponentName().getClassName().equals(
                        activity1.getComponentName().getClassName())) {
                    activity1.finish();
                    iterator.remove();
                }
            }
            removeAllKeepALock = false;
        }
    }

    // 遍历所有Activity并finish
    public void exitSystem() {
        for (Activity activity : activityList) {
            if (activity != null)
                activity.finish();
        }
        System.gc();
        Process.killProcess(Process.myPid());
        System.exit(0);
    }

    /**
     * 当前Activity
     */
    public Activity currentActivity() {
        if (activityList == null)
            activityList = initActivityList();
        int size = activityList.size();
        if (size == 0) return null;
        return activityList.get(size - 1);
    }

    /**
     * 获取保存的Activity数量
     */
    public int getActivitySize() {
        return initActivityList().size();
    }
}

这里只是简单的定义一个Activity管理类，在实际开发当中，Activity管理类不会只有这么简单。定义好Activity管理类之后，只需要在BaseActivity每次执行onCreate方法的时候进行添加addActivity，在BaseActivity每次执行onDestroy方法的时候进行移除removeActivity。最后在程序退出的时候执行ActivityUtil类中的exitSystem方法，例如，双击返回键退出程序功能，就可以在应用程序主页使用下面代码实现：

// 设置返回按钮的监听事件
private long exitTime = 0;

public boolean onKeyDown(int keyCode, KeyEvent event) {
    // 监听返回键，点击两次退出程序
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        if ((System.currentTimeMillis() - exitTime) > 5000) {
            Toast.makeText(getApplicationContext(), "再按一次退出程序", Toast.LENGTH_LONG).show();
            exitTime = System.currentTimeMillis();
        } else {
            ActivityUtil.getInstance().exitSystem();
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

四、对BACK、HOME等键统一处理

在BaseActivity中可以对BACK、HOME等键统一处理，例如点击返回键的实现，关闭当前页面：

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    // 点击手机上的返回键，返回上一层
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        this.finish();
        ActivityUtil.getInstance().removeActivity(this);
    }
    return super.onKeyDown(keyCode, event);
}

五、对网络状态变化进行实时监听

在Android系统中，当网络状态改变的时候，系统会发送一个名为CONNECTIVITY_ACTION的广播，如果要监听网络状态变化，就需要对该广播进行监听。如何监听？可以通过注册广播的方式。首先定义一个名为NetBroadcastReceiver的广播接收器，用来接收系统广播。代码如下：

/**
 * 检查网络状态切换 - 广播接受器
 *
 * @author 邹峰立
 */
public class NetBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // 如果相等的话就说明网络状态发生了变化
        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
            boolean netWorkState = NetworkUtil.isNetworkConnected(context);
            // 接口回调传过去状态的类型
            if (BaseActivity.netEvent != null)
                BaseActivity.netEvent.onNetChange(netWorkState);
        }
    }

    // 网络状态变化接口
    public interface NetChangeListener {
        void onNetChange(boolean netWorkState);
    }
}

在该类中定义一个对外接口NetChangeListener，该接口用来告诉外界当前网络状态，外界只需要实现该接口，就能够知道当前手机的网络状态。而BaseActivity.netEvent就是基类中实例化网络监听接口NetChangeListener的静态对象，通过该对象就可以将当前的网络状态传递给外界。

当然定义好广播接收器之后，还要在添加到清单文件中。

<!--注册广播-->
<receiver android:name=".broadcastreceiver.NetBroadcastReceiver">
     <intent-filter>
          <action
               android:name="android.net.conn.CONNECTIVITY_CHANGE"
               tools:ignore="BatteryLife" />
     </intent-filter>
</receiver>

同时网络状态监听，还需要权限，不要忘记加权限：

<!--网络状态权限-->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

另外，在该类中NetworkUtil是自定义的网络管理类，主要用来检测当前网络状态，代码如下：

/**
 * 网络工具类
 *
 * create by 邹峰立 on 2016/9/18
 */
public class NetworkUtil {
    public static final int NETTYPE_WIFI = 0x01;
    public static final int NETTYPE_CMWAP = 0x02;
    public static final int NETTYPE_CMNET = 0x03;

    /**
     * 检测网络是否可用
     */
    public static boolean isNetworkConnected(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = null;
        if (cm != null) {
            ni = cm.getActiveNetworkInfo();
        }
        return ni != null && ni.isConnectedOrConnecting();
    }

    /**
     * 获取当前网络类型
     *
     * @return 0：没有网络 1：WIFI网络 2：WAP网络 3：NET网络
     */
    public static int getNetworkType(Context context) {
        int netType = 0;
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = null;
        if (connectivityManager != null) {
            networkInfo = connectivityManager.getActiveNetworkInfo();
        }
        if (networkInfo == null) {
            return netType;
        }
        int nType = networkInfo.getType();
        if (nType == ConnectivityManager.TYPE_MOBILE) {
            String extraInfo = networkInfo.getExtraInfo();
            if (!TextUtils.isEmpty(extraInfo)) {
                if (extraInfo.toLowerCase().equals("cmnet")) {
                    netType = NETTYPE_CMNET;
                } else {
                    netType = NETTYPE_CMWAP;
                }
            }
        } else if (nType == ConnectivityManager.TYPE_WIFI) {
            netType = NETTYPE_WIFI;
        }
        return netType;
    }

}

六、权限申请封装

在Android6.0之后的版本，对一些特殊权限的时候就需要动态申请，可以利用BaseActivity基类实现权限申请封装。如何进行封装，首先要明白权限申请的几个步骤：

  1. 判断是否有该权限。
  2. 申请权限。
  3. 对权限申请结果进行处理。

所以对权限申请封装，也就是对这三个步骤进行封装，如下：

/**
 * 权限检查方法，false代表没有该权限，ture代表有该权限
 */
public boolean hasPermission(String... permissions) {
    for (String permission : permissions) {
        if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
            return false;
        }
    }
    return true;
}

/**
 * 权限请求方法
 */
public void requestPermission(int code, String... permissions) {
    ActivityCompat.requestPermissions(this, permissions, code);
}

/**
 * 处理请求权限结果事件
 *
 * @param requestCode  请求码
 * @param permissions  权限组
 * @param grantResults 结果集
 */
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    doRequestPermissionsResult(requestCode, grantResults);
}

/**
 * 处理请求权限结果事件
 *
 * @param requestCode  请求码
 * @param grantResults 结果集
 */
public void doRequestPermissionsResult(int requestCode, @NonNull int[] grantResults) {
}

七、更改应用程序字体大小

很多时候，应用程序需要实现修改字体大小功能，或者防止系统字体大小影响应用字体大小。这个实现可以通过在基类的onResume方法中进行操作。

@Override
protected void onResume() {
    super.onResume();
    Resources resources = this.getResources();
    Configuration configuration = resources.getConfiguration();
    configuration.fontScale = ConstantUtil.TEXTVIEWSIZE;
    resources.updateConfiguration(configuration, resources.getDisplayMetrics());
}

ConstantUtil.TEXTVIEWSIZE是设值的一个静态常量，当TEXTVIEWSIZE=1的时候，会显示系统标准字体大小，这个时候即使系统修改了字体大小，也不会影响到应用程序的字体大小。如果想要字体放大，设值其值>1即可。如果想要字体缩小，设值其值<1即可。

八、公共方法集成

几乎每一个Activity都要执行初始化方法，所以可以在BaseActivity基类定义一个私有抽象方法init，然后在onCreate进行调用，这样当继承该基类的Activity，就必须实现init，并在当前Activity的onCreate方法中自动执行。

1、修改状态栏的颜色

// 修改状态栏的颜色
public void setStatusBarColor(int color) {
    try {
        Window window = getWindow();
        // 取消设置透明状态栏,使 ContentView 内容不再覆盖状态栏
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
        }
        // 需要设置这个 flag 才能调用 setStatusBarColor 来设置状态栏颜色
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
        }
        // 设置状态栏颜色
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            window.setStatusBarColor(getResources().getColor(color));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

2、获取状态栏的高度

public int getStatusBarHeight() {
    Resources resources = getResources();
    int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
    if (resourceId > 0)
        return resources.getDimensionPixelSize(resourceId);
    return 0;
}

3、底部导航栏的高度

public int getNavigationBarHeight() {
    Resources resources = getResources();
    int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
    if (resourceId > 0)
        return resources.getDimensionPixelSize(resourceId);
    return 0;
}

4、判断底部导航栏是否显示

public boolean isNavigationBarShow() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        Display display = getWindowManager().getDefaultDisplay();
        Point size = new Point();
        Point realSize = new Point();
        display.getSize(size);
        display.getRealSize(realSize);
        return realSize.y != size.y;
    } else {
        boolean menu = ViewConfiguration.get(this).hasPermanentMenuKey();
        boolean back = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
        return !menu && !back;
    }
}

九、软盘统一控制
当Activity界面设计中，如果存在EditText输入框的话，很多时候要求，点击EditText外围隐藏软盘功能，如果有这种需求的话，就可以通过基类BaseActivity进行统一设置。

// 事件分发
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (isOpenKeyboardEvent) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            View v = getCurrentFocus();
            if (isShouldHideInput(v, ev)) {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                if (imm != null) {
                    imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
                }
            }
            return super.dispatchTouchEvent(ev);
        }
        // 必不可少，否则所有的组件都不会有TouchEvent了
        return getWindow().superDispatchTouchEvent(ev) || onTouchEvent(ev);
    } else {
        return super.dispatchTouchEvent(ev);
    }
}

private boolean isShouldHideInput(View v, MotionEvent event) {
    if (v != null && (v instanceof EditText)) {
        int[] leftTop = {0, 0};
        // 获取输入框当前的location位置
        v.getLocationInWindow(leftTop);
        int left = leftTop[0];
        int top = leftTop[1];
        int bottom = top + v.getHeight();
        int right = left + v.getWidth();
        return !(event.getX() > left) || !(event.getX() < right)
                    || !(event.getY() > top) || !(event.getY() < bottom);
    }
    return false;
}

最后，给出完整BaseActivity基类代码

/**
 * BaseActivity是所有Activity的基类，把一些公共的方法放到里面，如基础样式设置，权限封装，网络状态监听等
 * <p>
 * Created by 邹峰立 on 2018/3/5.
 */
public abstract class BaseActivity extends AppCompatActivity implements NetBroadcastReceiver.NetChangeListener {
    public static NetBroadcastReceiver.NetChangeListener netEvent;// 网络状态改变监听事件
    private boolean isOpenKeyboardEvent = true;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 执行初始化方法
        isOpenKeyboardEvent = initIsOpenKeyboardEvent();

        // 隐藏标题栏
        if (getSupportActionBar() != null)
            getSupportActionBar().hide();

//        // 沉浸效果
//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
//            // 透明状态栏
//            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
//            // 透明导航栏
//            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
//        }

        // 添加到Activity工具类
        ActivityUtil.getInstance().addActivity(this);

        // 初始化netEvent
        netEvent = this;
    }

    // 抽象 - 初始化方法，可以对数据进行初始化
    protected abstract boolean initIsOpenKeyboardEvent();

    @Override
    protected void onResume() {
        super.onResume();
        Resources resources = this.getResources();
        Configuration configuration = resources.getConfiguration();
        configuration.fontScale = ConstantUtil.TEXTVIEWSIZE;
        resources.updateConfiguration(configuration, resources.getDisplayMetrics());
    }

    @Override
    protected void onDestroy() {
        // Activity销毁时，提示系统回收
        // System.gc();
        netEvent = null;
        // 移除Activity
        ActivityUtil.getInstance().removeActivity(this);
        super.onDestroy();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        // 点击手机上的返回键，返回上一层
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            // 移除Activity
            ActivityUtil.getInstance().removeActivity(this);
            this.finish();
        }
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 权限检查方法，false代表没有该权限，ture代表有该权限
     */
    public boolean hasPermission(String... permissions) {
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }


    /**
     * 权限请求方法
     */
    public void requestPermission(int code, String... permissions) {
        ActivityCompat.requestPermissions(this, permissions, code);
    }

    /**
     * 处理请求权限结果事件
     *
     * @param requestCode  请求码
     * @param permissions  权限组
     * @param grantResults 结果集
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        doRequestPermissionsResult(requestCode, grantResults);
    }

    /**
     * 处理请求权限结果事件
     *
     * @param requestCode  请求码
     * @param grantResults 结果集
     */
    public void doRequestPermissionsResult(int requestCode, @NonNull int[] grantResults) {
    }

    /**
     * 网络状态改变时间监听
     *
     * @param netWorkState true有网络，false无网络
     */
    @Override
    public void onNetChange(boolean netWorkState) {
    }

    // 修改状态栏的颜色
    public void setStatusBarColor(int color) {
        try {
            Window window = getWindow();
            // 取消设置透明状态栏,使 ContentView 内容不再覆盖状态栏
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            }
            // 需要设置这个 flag 才能调用 setStatusBarColor 来设置状态栏颜色
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            }
            // 设置状态栏颜色
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                window.setStatusBarColor(getResources().getColor(color));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取状态栏的高度
    public int getStatusBarHeight() {
        Resources resources = getResources();
        int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0)
            return resources.getDimensionPixelSize(resourceId);
        return 0;
    }

    // 底部导航栏的高度
    public int getNavigationBarHeight() {
        Resources resources = getResources();
        int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
        if (resourceId > 0)
            return resources.getDimensionPixelSize(resourceId);
        return 0;
    }

    // 判断底部导航栏是否显示
    public boolean isNavigationBarShow() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            Display display = getWindowManager().getDefaultDisplay();
            Point size = new Point();
            Point realSize = new Point();
            display.getSize(size);
            display.getRealSize(realSize);
            return realSize.y != size.y;
        } else {
            boolean menu = ViewConfiguration.get(this).hasPermanentMenuKey();
            boolean back = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
            return !menu && !back;
        }
    }

    // 事件分发
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (isOpenKeyboardEvent) {
            if (ev.getAction() == MotionEvent.ACTION_DOWN) {
                View v = getCurrentFocus();
                if (isShouldHideInput(v, ev)) {
                    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                    if (imm != null) {
                        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
                    }
                }
                return super.dispatchTouchEvent(ev);
            }
            // 必不可少，否则所有的组件都不会有TouchEvent了
            return getWindow().superDispatchTouchEvent(ev) || onTouchEvent(ev);
        } else {
            return super.dispatchTouchEvent(ev);
        }
    }

    private boolean isShouldHideInput(View v, MotionEvent event) {
        if (v != null && (v instanceof EditText)) {
            int[] leftTop = {0, 0};
            // 获取输入框当前的location位置
            v.getLocationInWindow(leftTop);
            int left = leftTop[0];
            int top = leftTop[1];
            int bottom = top + v.getHeight();
            int right = left + v.getWidth();
            return !(event.getX() > left) || !(event.getX() < right)
                    || !(event.getY() > top) || !(event.getY() < bottom);
        }
        return false;
    }
}

Activity继承实现

public class MainActivity extends BaseActivity {
    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initView();

        // 判断权限
        if (!hasPermission(Manifest.permission.READ_PHONE_STATE)) {
            requestPermission(ConstantUtil.PERMISSIONS_REQUEST_READ_PHONE_STATE, Manifest.permission.READ_PHONE_STATE);
        }
    }

    @Override
    protected boolean initIsOpenKeyboardEvent() {
        return false;
    }

    // 初始化控件
    private void initView() {
        textView = findViewById(R.id.text);
    }

    // 处理请求权限结果
    @Override
    public void doRequestPermissionsResult(int requestCode, @NonNull int[] grantResults) {
        switch (requestCode) {
            case ConstantUtil.PERMISSIONS_REQUEST_READ_PHONE_STATE:// 读取手机信息权限
                if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    // 权限请求成功
                    Toast.makeText(this, "权限请求成功", Toast.LENGTH_SHORT).show();
                } else {
                    // 权限请求失败
                    Toast.makeText(this, "权限请求失败", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }

    // 处理网络状态结果
    @Override
    public void onNetChange(boolean netWorkState) {
        super.onNetChange(netWorkState);
        if (textView != null)
            textView.setText(netWorkState ? "有网络" : "无网络");
    }

    // 设置返回按钮的监听事件
    private long exitTime = 0;

    public boolean onKeyDown(int keyCode, KeyEvent event) {
        // 监听返回键，点击两次退出程序
        if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
            if ((System.currentTimeMillis() - exitTime) > 5000) {
                Toast.makeText(getApplicationContext(), "再按一次退出程序", Toast.LENGTH_LONG).show();
                exitTime = System.currentTimeMillis();
            } else {
                ActivityUtil.getInstance().exitSystem();
            }
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }
}

Github地址

微信公众号：伴职创作

感谢您使用伴职平台，如有侵权，请投诉删除！

全部评价

最新
查看更多评论 加载

猜你喜欢

换一批