第一行代码（十）

第十章主要讲 Android 中四大组件的服务

一、什么是服务

  服务是 Android 中实现程序后台运行的解决方案，适合去执行那些不需要和用户交互而且要长期运行的任务，即使程序被切换到后台，或者用户打开了另一个应用程序，服务仍然能够保持正常运行。

注意：服务并不是运行在一个独立的进程当中，而是依赖于创建服务时所在的应用程序进程，当某个应用程序被进程杀掉时，所有依赖于该进程的服务也会停止运行。另外，服务并不会自动开启线程，所有的代码都是默认运行在主线程当中的，所以如果要进行耗时操作，我们需要在服务的内部手动创建子线程，否则就有可能出现主线程被阻塞的情况。

二、Android 多线程编程

  新建一个类继承自 Thread，然后重写 run()方法

public class MyThread extends Thread {

    @Override
    public void run() {
        super.run();
    }
    
}

new MyThread().start();

但是使用继承的方式耦合性有点高，更多的时候我们会选择实现 Runnable 接口的方式来定义一个线程

public class MyThread implements Runnable {

    @Override
    public void run() {
        
    }
}

        MyThread myThread = new MyThread();
        new Thread(myThread).start();

  知道了如何开启线程后，我们需要注意，Android 的 UI 是线程不安全的，因此，如果想要更新应用程序里的 UI 元素，必须在主线程中进行，否则会出现异常。如果在子线程中进行了 UI 更新的操作，会报错。
  对于这种情况，Android 提供了一套异步消息处理机制，完美地解决了在子线程中进行 UI 操作的问题。

三、异步消息处理机制

        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = Message.obtain();
                        msg.what = UPDATE_TEXT;
                        handler.sendMessage(msg);
                    }
                }).start();
            }
        });

    public static final int UPDATE_TEXT = 1;

    private Handler handler = new Handler() {
        /**
         * 该方法是运行在主线程当中的
         */
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case UPDATE_TEXT:
                    tv.setText("这里是主线程，可以进行 UI 操作");
                    break;
                default:
                    break;
            }
        }
    };

  上面是异步消息的代码，下面来解析异步消息处理机制。Android 中的异步消息处理主要由4个部分组成：Message、Handler、MessageQueue 和 Looper

• Message：
    Message 是在线程之间传递的消息，内部可携带少量的信息，Message 不仅可以使用 what 字段，还可以使用 arg1和 arg2字段来携带一些整形数据，还可以使用 obj 字段携带一个 Object 对象。
• Handler：
    顾名思义，是处理者的意思，主要用于发送和处理消息，发送消息一般使用 Handler 的 sendMessage()方法，发出的消息经过辗转处理后，最终会传递到 Handler 的 handleMessage()方法中。
• MessageQueue：
    是消息队列的意思，主要用于存放所有通过 Handler 发送的消息，这部分消息一直会存在于消息队列中，等待被处理，每个线程中只会有一个 MessageQueue 对象。
• Looper：
    Looper 是每个线程中的 MessageQueue 的管家，调用 Looper 的 loop()方法后，就会进入到一个无限循环当中，然后每当发现 MessageQueue 中存在一条消息，就会将它取出，并传递到 Handler 的 handleMessage()方法中，每个线程中也只会有一个 Looper 对象。

整体梳理：首先在主线程中创建一个 Handler 对象，并重写 handleMessage()方法，然后当子线程中需要进行 UI 操作时，就创建一个 Message 对象，并通过 Handler 将这条消息发送出去。之后这条消息会被添加到 MessageQueue 的队列中等待被处理，而 Looper 则会一直尝试从 MessageQueue 中取出待处理的消息，然后分发回 Handler 的 handleMessage()方法中。由于 Handler 是在主线程中创建的，所以此时 handleMessage()方法中的代码也会在主线程中运行。

我们以前使用到的 runOnUiThread()方法其实就是一个异步消息处理机制的接口封装。

四、使用 AsyncTask

  AsyncTask 背后的实现原理也是基于异步消息处理机制的，只是 Android 帮我们做了很好的封装而已，AsyncTask 是一个抽象类，所以我们要创建一个子类去继承它，在继承的时候可以为 AsyncTask 指定3个泛型参数（如果不需要，可以写 Void）：

1. Params：在执行 AsyncTask 时传入的参数，可用于在后台任务中使用。

2.Progress：后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。

3.Result：当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

public class DownloadTask extends AsyncTask {

    /**
     * 在后台任务开始执行之前调用，用于进行一些界面上的初始化操作
     */
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    /**
     * 该方法中的所有代码都会在子线程中运行，任务一旦完成就可以通过
     * return 语句来将任务的执行结果返回，如果 AsyncTask 的第三个
     * 泛型参数指定的是 Void 就可以不反悔任务执行结果
     * 注意：该方法中是不可以进行 UI 操作的，如果需要更新 UI
     * 元素，比如反馈当前任务的执行进度，可以调用 publishProgress 方法来完成
     */
    @Override
    protected Boolean doInBackground(Void... integers) {
        return null;
    }

    /**
     * 当在后台任务重调用了 publishProgress 方法后，该方法就会很快被
     * 调用，该方法中携带的参数就是在后台任务重传递过来的。在该方法中
     * 可以对 UI 进行操作。
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
    }

    /**
     * 当后台任务执行完毕并通过 return 语句进行返回时，该方法就会很快调用，
     * 返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些 UI 操作，
     * 比如提醒任务执行的结果，以及关闭进度条对话框等。
     */
    @Override
    protected void onPostExecute(Boolean aBoolean) {
        super.onPostExecute(aBoolean);
    }
}

new DownloadTask().execute();

整体来说，就是在 doInBackground()方法中执行具体的耗时任务，在 onProgressUpdate()方法中进行 UI 操作，在 onPostExecute()方法中执行一些任务的收尾工作。

五、服务

image.png

public class MyService extends Service {
    public MyService() {
    }

    /**
     * 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
     */
    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * 创建服务的时候调用
     */
    @Override
    public void onCreate() {
        super.onCreate();
    }

    /**
     * 每次服务启动的时候调用
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 服务销毁的时候调用
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

启动和停止服务

        findViewById(R.id.tv_start_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                /*
                    startService 定义在 Context 类中
                 */
                Intent intent = new Intent(FifthActivity.this,MyService.class);
                startService(intent);
            }
        });

        findViewById(R.id.tv_stop_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                /*
                    stopService 定义在 Context 类中
                 */
                Intent intent = new Intent(FifthActivity.this,MyService.class);
                stopService(intent);
            }
        });

注意，这里完全是由活动来决定服务何时停止的，如果没有点击 Stop Service按钮，服务就会一直处于运行状态，如果让服务自己停下来，可以在 MyService 的任何一个位置调用 stopSelf()方法就行了。

活动和服务进行通信

  如何让活动和服务进行通信呢？例如在活动中指挥服务去干什么，服务就去干什么，这就叫借助 onBind()方法了。

public class MyService extends Service {

    private static final String TAG = "MyService";

    private DownloadBinder mBinder = new DownloadBinder();

    /**
     * 新建一个类继承自 Binder
     */
    class DownloadBinder extends Binder{

        public void startDownload(){
            System.out.println("abc : startDownload");
        }

        public void getProgress(){
            System.out.println("abc : getProgress");
        }
    }

    public MyService() {
    }

    /**
     * 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
     */
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "abc onBind: ");
        //返回 DownloadBinder 实例对象
        return mBinder;
    }

    /**
     * 创建服务的时候调用
     */
    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("abc : onCreate");
    }

    /**
     * 每次服务启动的时候调用
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("abc : onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 服务销毁的时候调用
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("abc : onDestroy");
    }
}

    private MyService.DownloadBinder downloadBinder;

    /**
     * 首先要创建 ServiceConnection 匿名类，重写 onServiceConnected()方法
     * 和 onServiceDisconnected()方法，这两个方法分别会在活动和服务成功绑定
     * 以及解除绑定的时候调用
     */
    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //向下转型获取 DownloadBinder 实例对象，有了该实例对象，我们就可以调用相应的方法了
            downloadBinder = (MyService.DownloadBinder) iBinder;
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

        findViewById(R.id.tv_bind_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(FifthActivity.this,MyService.class);
                /*
                    该方法接受三个参数
                        参1：Intent
                        参2：ServiceConnection
                        参3：BIND_AUTO_CREATE,表示在活动和服务进行绑定后自动创建服务
                            这就会使onCreate()方法得到执行，onStartCommand()方法不会执行。
                 */
                bindService(intent,connection,BIND_AUTO_CREATE);//绑定服务
            }
        });

        findViewById(R.id.tv_unbind_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                unbindService(connection);//解绑服务
            }
        });

image.png

注意：任何一个服务在整个应用程序范围内都是通用的，可以和任何一个其他的活动进行绑定，而且在绑定完成后他们都可以获取到相同的 DownloadBinder 实例对象

服务的生命周期

  只要调用了 Context 的 startService()方法，相应的服务就会启动起来，并回调 onStartConmmand()方法，如果这个服务之前还没有创建过，onCreate()方法会先于 onStartCommand()方法执行。服务一旦启动之后，会一直保持运行状态，直到 stopService()或stopSelf()方法被调用。注意，虽然每调用一次 startService()方法，onStartCommand()就会执行一次，但实际上每个服务都只会存在一个实例，所以不管你调用多少次 startService()，只需调用一次 stopService()或stopSelf()方法，服务就会停下来。
  另外，还可以调用 Context 的 bindService()来获取一个服务的持久连接，这时就会回调服务中的 onBind()方法。类似的，如果服务之前还没有创建过，onCreate()方法会先于 onBind()方法执行。然后，调用方可以获取到 onBind()方法里返回的 IBinder 对象实例。只要调用方和服务之间的连接没有断开，服务就会一直保持运行状态。
  当调用了 startService()方法后，又去调用 stopService()方法，这时服务中 onDestroy()方法就会执行，表示服务已经销毁了。类似的，当调用了 bindService()方法后，又去调用 unbindService()方法，onDestroy()方法也会执行。但是，注意，我们可能一个服务既调用了 startService()又调用了 bindService()方法，那么该如何销毁服务呢？根据 Android 系统的机制，一个服务只要被启动或者被绑定了之后，就会一直处于运行状态，必须要让以上两种条件同时不满足，服务才能被销毁，所以，这种情况下要同时调用 stopService()和 unbindService()方法，onDetroy()方法才会执行。

六、服务的更多技巧

前台服务

  服务的系统优先级并不高，当系统出现内存不足的情况时，就有可能会回收掉正在后台运行的服务。如果你希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被系统回收，就可以考虑使用前台服务。前台服务和普通服务最大的区别就在于，前台服务会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。

    public class MyService extends Service {

    private static final String TAG = "MyService";

    public MyService() {
    }

    /**
     * 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
     */
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "abc onBind: ");
        //返回 DownloadBinder 实例对象
        return mBinder;
    }

    /**
     * 创建服务的时候调用
     */
    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("abc : onCreate");
        //创建 Intent
        Intent intent = new Intent(this,FifthActivity.class);
        //创建 PendingIntent
        PendingIntent pendingIntent = PendingIntent.getActivity(this,0,intent,0);
        //创建 Notification
        Notification notification = new NotificationCompat.Builder(this)
                .setContentText("this is text")
                .setContentTitle("this is title")
                .setWhen(System.currentTimeMillis())
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentIntent(pendingIntent)
                .build();
        /*
            接收两个参数：
                参1：通知的 id
                参2：Notification 对象
         */
        startForeground(1,notification);
    }

    //...
}

使用 IntentService

  如果使用传统的 Service，如果要执行耗时操作，需要自己手动创建线程，而且在执行完毕要记得调动 stopSelf()方法关闭。为了可以简单地创建一个异步的、会自动停止的服务，Android 专门提供了一个 IntentService 类。

public class MyIntentService extends IntentService {

    /**
     * 自己改成无参构造函数，并且必须在内部调用父类的
     * 有参构造函数
     */
    public MyIntentService() {
        super("MyIntentService");
    }

    /**
     * 该方法是运行在子线程当中
     */
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        System.out.println("abc : onHandleIntent");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("abc onDestroy");
    }
}

        findViewById(R.id.tv_intent_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(FifthActivity.this,MyIntentService.class);
                startService(intent);
            }
        });

七、多线程断点下载

public class DownloadTask extends AsyncTask {

    private static final int TYPE_SUCCESS = 0;
    private static final int TYPE_FAILED = 1;
    private static final int TYPE_PAUSED = 2;
    private static final int TYPE_CANCELED = 3;

    private DownloadListener downloadListener;

    private boolean isCanceled = false;
    private boolean isPaused = false;
    private int lastProgress;

    public DownloadTask(DownloadListener downloadListener) {
        this.downloadListener = downloadListener;
    }

    @Override
    protected Integer doInBackground(String... strings) {
        InputStream is = null;
        RandomAccessFile savedFile = null;
        File file = null;
        try {
            long downloadedLength = 0;//记录已下载的文件长度
            /*
                获取下载的 URL 地址，并根据 URL 地址解析出下载的文件名，
                然后指定将文件下载到 Environment.DIRECTORY_DOWNLOADS 目录下，
                也就是 SD 卡的 Download 目录
             */
            String downloadUrl = strings[0];
            String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
            String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
                    .getParent();
            file = new File(directory + fileName);
            /*
                判断该目录下是否已经存在要下载的文件,如果存在就获取该文件的字节数，
                便于在后面启动断点续传的功能
             */
            if (file.exists()) {
                downloadedLength = file.length();
            }
            long contentLength = getContentLength(downloadUrl);
            if (contentLength == 0) {//文件长度为0，说明文件有问题，下载失败
                return TYPE_FAILED;
            } else if (contentLength == downloadedLength) {//文件长度等于已下载的文件长度，则下载完成
                return TYPE_SUCCESS;
            }
            //从网络下载文件，通过流的方式写入到本地
            OkHttpClient okHttpClient = new OkHttpClient();
            Request request = new Request.Builder()
                    //断点下载，指定从哪个字节开始下载
                    .addHeader("RANGE", "bytes=" + downloadedLength + "-")
                    .url(downloadUrl)
                    .build();
            Response response = okHttpClient.newCall(request).execute();
            if (response != null) {
                is = response.body().byteStream();
                savedFile = new RandomAccessFile(file, "rw");
                byte[] b = new byte[1024];
                int total = 0;
                int len;
                while ((len = is.read(b)) != -1) {
                    /*
                        判断用户有没有触发暂停或者取消的操作，
                        如果没有触发暂停或者取消的操作，就计算当前的下载进度
                     */
                    if (isCanceled) {
                        return TYPE_CANCELED;
                    } else if (isPaused) {
                        return TYPE_PAUSED;
                    } else {
                        total += len;
                    }
                    savedFile.write(b, 0, len);
                    //计算已下载的百分比
                    int progress = (int) ((total + downloadedLength) * 100 / contentLength);
                    //通知更新界面
                    publishProgress(progress);
                }
                response.body().close();
            }
            return TYPE_SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if(savedFile != null){
                    savedFile.close();
                }
                if(isCanceled && file != null){
                    file.delete();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return TYPE_FAILED;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        int progress = values[0];
        if(progress > lastProgress){
            downloadListener.onProgress(progress);
            lastProgress = progress;
        }
    }

    /**
     * 根据下载完成的状态来进行回调
     */
    @Override
    protected void onPostExecute(Integer status) {
        super.onPostExecute(status);
        switch (status){
            case TYPE_SUCCESS:
                downloadListener.onSuccess();
                break;
            case TYPE_FAILED:
                downloadListener.onFailed();
                break;
            case TYPE_PAUSED:
                downloadListener.onPaused();
                break;
            case TYPE_CANCELED:
                downloadListener.onCanceled();
                break;
            default:
                break;
        }
    }

    /**
     * 暂停下载
     */
    public void pauseDownload(){
        isPaused = true;
    }

    /**
     * 取消下载
     */
    public void cancelDownload(){
        isCanceled = true;
    }

    /**
     * 获取下载文件的总长度
     */
    private long getContentLength(String downloadUrl) throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url(downloadUrl)
                .build();
        Response response = okHttpClient.newCall(request).execute();
        if(response != null && response.isSuccessful()){
            long contentLength = response.body().contentLength();
            response.close();
            return contentLength;
        }
        return 0;
    }
}

public class DownloadService extends Service {

    private DownloadTask downloadTask;

    private String downloadUrl;

    private DownloadBinder mBinder = new DownloadBinder();

    public DownloadService() {
    }

    class DownloadBinder extends Binder {

        public void startDownload(String url) {
            if (downloadTask == null) {
                downloadUrl = url;
                downloadTask = new DownloadTask(listener);
                downloadTask.execute(downloadUrl);
                startForeground(1, getNotification("Downloading...", 0));
                Toast.makeText(DownloadService.this, "Downloading...", Toast.LENGTH_SHORT).show();
            }
        }

        public void pauseDownload() {
            if (downloadTask != null) {
                downloadTask.pauseDownload();
            }
        }

        public void cancelDownload() {
            if (downloadTask != null) {
                downloadTask.cancelDownload();
            } else {
                if(downloadUrl != null){
                    //取消下载时需将文件删除，并关闭通知
                    String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
                    String directory = Environment.getExternalStoragePublicDirectory(
                            Environment.DIRECTORY_DOWNLOADS).getPath();
                    File file = new File(directory + fileName);
                    if(file.exists()){
                        file.delete();
                    }
                    getNotificationManager().cancel(1);
                    stopForeground(true);
                    Toast.makeText(DownloadService.this, "Canceled", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }

    private DownloadListener listener = new DownloadListener() {
        @Override
        public void onProgress(int progress) {
            getNotificationManager().notify(1, getNotification("Downloading...", progress));
        }

        @Override
        public void onSuccess() {
            downloadTask = null;
            //下载成功时将前台服务通知关闭，并创建一个下载成功的通知
            stopForeground(true);
            getNotificationManager().notify(1, getNotification("Download Success", -1));
            Toast.makeText(DownloadService.this, "下载成功", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onFailed() {
            downloadTask = null;
            //下载失败时将前台服务通知关闭，并创建一个下载失败的通知
            stopForeground(true);
            getNotificationManager().notify(1, getNotification("Download Failed", -1));
            Toast.makeText(DownloadService.this, "Download Failed", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onPaused() {
            downloadTask = null;
            Toast.makeText(DownloadService.this, "Download Pause", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onCanceled() {
            downloadTask = null;
            stopForeground(true);
            Toast.makeText(DownloadService.this, "Download Cancel", Toast.LENGTH_SHORT).show();
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    private NotificationManager getNotificationManager() {
        return (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    }

    private Notification getNotification(String title, int progress) {
        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
        builder.setContentTitle(title)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentIntent(pendingIntent)
                .build();
        if (progress >= 0) {
            //当 progress > 0 或者 = 0 时才需显示下载进度
            builder.setContentText(progress + "%");
            /*
                参1：通知的最大进度
                参2：通知的当前进度
                参3：是否使用模糊进度条
             */
            builder.setProgress(100, progress, false);
        }
        return builder.build();
    }
}

public class DownloadActivity extends AppCompatActivity implements View.OnClickListener{

    private DownloadService.DownloadBinder downloadBinder;

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            downloadBinder = (DownloadService.DownloadBinder) iBinder;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

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

        TextView startDownload = (TextView) findViewById(R.id.tv_start_download);
        TextView pauseDownload = (TextView) findViewById(R.id.tv_pause_download);
        TextView cancelDownload = (TextView) findViewById(R.id.tv_cancel_download);

        startDownload.setOnClickListener(this);
        pauseDownload.setOnClickListener(this);
        cancelDownload.setOnClickListener(this);

        Intent intent = new Intent(this,DownloadService.class);
        //启动服务，保证服务一直在后台运行
        startService(intent);
        //使活动和服务进行交互
        bindService(intent,connection,BIND_AUTO_CREATE);
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.tv_start_download:
                String url = "https://raw.githubusercontent.com/guolindev/eclipse/master/eclipse-inst-win64.exe";
                downloadBinder.startDownload(url);
                break;
            case R.id.tv_pause_download:
                downloadBinder.pauseDownload();
                break;
            case R.id.tv_cancel_download:
                downloadBinder.cancelDownload();
                break;
            default:
                break;
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode){
            case 1:
                if(grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED){
                    Toast.makeText(this, "拒绝权限将无法使用程序", Toast.LENGTH_SHORT).show();
                }
                break;
            default:
                break;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注意：一定要在活动销毁的时候解绑服务，否则会造成内存泄漏
        unbindService(connection);
    }
}

下一篇文章：https://www.jianshu.com/p/41ca26fb4f10