服务的最佳实践——完整版的下载示例

小灰灰 2023-10-08 22:34 9阅读 0赞

在学习Android service的时候遇到一些问题，在搜索资料之后得到解决，在此记录

本节中我们将要编写一个完整版的下载示例。

创建一个ServiceBestPractice项目，然后开始本节内容。首先我们需要将项目中会使用到的依赖库添加好，编辑app/build.gradle文件，在dependencies闭包中添加如下内容：

dependencies {
    	implementation "com.squareup.okhttp3:okhttp:4.2.2"
    }

只需添加一个OkHttp的依赖就行了，待会儿在编写网络相关的功能时，我们将使用OkHttp来进行实现。

接下来需要定义一个回调接口，用于对下载过程中的各种状态进行监听和回调。新建一个DownloadListener接口，代码如下所示：

package com.zhouzhou.servicebestpractice;
    
    public interface DownloadListener {
        //用于通知当前的下载进度
        void onProgress(int progress);
        //用于通知下载成功事件
        void onSuccess();
        //用于通知下载失败事件
        void onFailed();
        //用于通知下载暂停事件
        void onPaused();
        //用于通知下载取消事件
        void onCanceled();
    }

一共定义了5个回调方法。回调接口定义好了之后，下面可以开始编写下载功能了。这里使用本章中刚学的AsyncTask来进行实现，新建一个DownloadTask继承自AsyncTask，代码如下所示：

package com.zhouzhou.servicebestpractice;
    
    import android.os.AsyncTask;
    import android.os.Environment;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.RandomAccessFile;
    
    import okhttp3.OkHttpClient;
    import okhttp3.Request;
    import okhttp3.Response;
    
    /**
     * 在AsyncTask中的3个泛型参数：
     * 第一个泛型参数指定为String，表示在执行AsyncTask的时候需要传入一个字符串参数给后台任务；
     * 第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位；
     * 第三个泛型参数指定为Integer，则表示使用整型数据来反馈执行结果。
     */
    public class DownloadTask extends AsyncTask<String,Integer,Integer> {
        public static final int TYPE_SUCCESS = 0; //下载成功
        public static final int TYPE_FAILED = 1; //下载失败
        public static final int TYPE_PAUSED = 2; //暂停下载
        public static final int TYPE_CANCELED = 3; //取消下载
        private DownloadListener listener;
        private boolean isCanceled = false;
        private boolean isPaused = false;
        private int lastProgress;
    
        // 在DownloadTask的构造函数中要求传入一个刚刚定义的DownloadListener参数，待会就会将下载的状态通过这个参数进行回调。
        public DownloadTask(DownloadListener listener) {
            this.listener = listener;
        }
    
        /**
         * doInBackground()方法：
         * 首先从参数中获取到了下载的URL地址，并根据URL地址解析出了下载的文件名；
         * 然后指定将文件下载到Environment.DIRECTORY_DOWNLOADS目录下，也就是SD卡的Download目录；
         */
        @Override
        protected Integer doInBackground(String... params) {
            InputStream is = null;
            RandomAccessFile savedFile = null;
            File file = null;
            try {
                long downloadedLength = 0;// 记录已下载的文件长度
                String downloadUrl = params[0];
                String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
                String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath();
                file = new File(directory + fileName);
                if (file.exists()) {
                    //还要判断一下Download目录中是不是已经存在要下载的文件了，
                    // 如果已经存在的话则读取已下载的字节数，这样就可以在后面启用断点续传的功能。
                    downloadedLength = file.length();
                }
                //先是调用了getContentLength()方法来获取待下载文件的总长度，
                // 如果文件长度等于0则说明文件有问题，直接返回TYPE_FAILED，
                // 如果文件长度等于已下载文件长度，那么就说明文件已经下载完了，直接返回TYPE_SUCCESS即可
                long contentLength = getContentLength(downloadUrl);
                if (contentLength == 0) {
                    return TYPE_FAILED;
                } else if (contentLength == downloadedLength) {
                    //已下载字节和文件总字节数相等，说明已经下载完成了
                    return TYPE_SUCCESS;
                }
                //使用OkHttp来发送一条网络请求，需要注意的是，这里在请求中添加了一个header，
                // 用于告诉服务器我们想要从哪个字节开始下载，因为已下载过的部分就不需要再重新下载了。
                OkHttpClient client = new OkHttpClient();
                Request request = new Request.Builder()
                        // 断点下载，指定从哪个字节开始下载
                        .addHeader("RANGE","bytes=" + downloadedLength + "-")
                        .url(downloadUrl)
                        .build();
                Response response = client.newCall(request).execute();
                //使用Java的文件流方式，不断从网络上读取数据，不断写入到本地，一直到文件全部下载完成为止。
                if (response != null) {
                    is = response.body().byteStream();
                    savedFile = new RandomAccessFile(file,"rw");
                    savedFile.seek(downloadedLength);//跳过已经下载的字节
                    byte[] b = new byte[1024];
                    int total = 0;
                    int len;
                    //在这个过程中，我们还要判断用户有没有触发暂停或者取消的操作，
                    // 如果有的话则返回TYPE_PAUSED或TYPE_CANCELED来中断下载，
                    // 如果没有的话则实时计算当前的下载进度，然后调用publishProgress()方法进行通知。
                    // 暂停和取消操作都是使用一个布尔型的变量来进行控制的，调用pauseDownload()或cancelDownload()方法即可更改变量的值。
                    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 (Exception e) {
                    e.printStackTrace();
                }
            }
            return TYPE_FAILED;
        }
    
        /**
         * onProgressUpdate()方法：
         * 它首先从参数中获取到当前的下载进度，然后和上一次的下载进度进行对比，
         * 如果有变化的话则调用DownloadListener的onProgress()方法来通知下载进度更新。
         */
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            int progress = values[0];
            if (progress > lastProgress) {
                listener.onProgress(progress);
                lastProgress = progress;
            }
        }
    
        /**
         * onPostExecute()方法:是根据参数中传入的下载状态来进行回调。
         * 下载成功就调用DownloadListener的onSuccess()方法，
         * 下载失败就调用onFailed()方法，暂停下载就调用onPaused()方法，
         * 取消下载就调用onCanceled()方法。
         */
        @Override
        protected void onPostExecute(Integer status) {
            super.onPostExecute(status);
            switch (status) {
                case TYPE_SUCCESS:
                    listener.onSuccess();
                    break;
                case TYPE_FAILED:
                    listener.onFailed();
                    break;
                case TYPE_PAUSED:
                    listener.onPaused();
                    break;
                case TYPE_CANCELED:
                    listener.onCanceled();
                    break;
                default:
                    break;
            }
        }
        public void  pauseDownload() {
            isPaused = true;
        }
        public void cancelDownload() {
            isCanceled = true;
        }
        private long getContentLength(String downloadUrl)throws IOException {
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder()
                    .url(downloadUrl)
                    .build();
            Response response = client.newCall(request).execute();
            if (response != null && response.isSuccessful()) {
                long contentLength = response.body().contentLength();
                response.body().close();
                return contentLength;
            }
            return 0;
        }
    }

这样就把具体的下载功能完成了，下面为了保证DownloadTask可以一直在后台运行，还需要创建一个下载的服务。右击com.zhouzhou.servicebestpractice→New→Service→Service，新建DownloadService，然后修改其中的代码，如下所示：

package com.zhouzhou.servicebestpractice;
    
    import android.app.Notification;
    import android.app.NotificationManager;
    import android.app.PendingIntent;
    import android.app.Service;
    import android.content.Intent;
    import android.graphics.BitmapFactory;
    import android.os.Binder;
    import android.os.Environment;
    import android.os.IBinder;
    import android.widget.Toast;
    
    import androidx.core.app.NotificationCompat;
    
    import java.io.File;
    
    public class DownloadService extends Service {
        private DownloadTask downloadTask;
        private String downloadUrl;
        // 首先这里创建了一个DownloadListener的匿名类实例，
        // 并在匿名类中实现了onProgress()、onSuccess()、onFailed()、onPaused()和onCanceled()这5个方法。
        private DownloadListener listener = new DownloadListener() {
            @Override
            public void onProgress(int progress) {
                //在onProgress()方法中，调用getNotification()方法构建了一个用于显示下载进度的通知，
                //然后调用NotificationManager的notify()方法去触发这个通知，这样就可以在下拉状态栏中实时看到当前下载的进度了。
                getNotificationManager().notify(1,getNotification("Downloading...",progress));
            }
            @Override
            public void onSuccess() {
                //在onSuccess()方法中，首先是将正在下载的前台通知关闭，然后创建一个新的通知用于告诉用户下载成功了。
                //其他几个方法也都是类似的，分别用于告诉用户下载失败、暂停和取消这几个事件。
                downloadTask = null;
                //下载成功时将前台服务通知关闭，并创建一个下载成功的通知
                stopForeground(true);
                getNotificationManager().notify(1,getNotification("Download Success",-1));
                Toast.makeText(DownloadService.this,"Download Success",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,"Paused",Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onCanceled() {
                downloadTask = null;
                stopForeground(true);
                Toast.makeText(DownloadService.this,"Canceled",Toast.LENGTH_SHORT).show();
            }
        };
        //为了要让DownloadService可以和活动进行通信，又创建了一个DownloadBinder。
        private DownloadBinder mBinder = new DownloadBinder();
        @Override
        public IBinder onBind(Intent intent) {
            // TODO: Return the communication channel to the service.
            //throw new UnsupportedOperationException("Not yet implemented");
            return mBinder;
        }
    
        // DownloadBinder中提供了startDownload()、pauseDownload()和cancelDownload()这3个方法。
        class DownloadBinder extends Binder {
            public void startDownload(String url) {
                if (downloadTask == null) {
                    downloadUrl = url;
                    //创建了一个DownloadTask的实例，把刚才的DownloadListener作为参数传入，
                    //然后调用execute()方法开启下载，并将下载文件的URL地址传入到execute()方法中。
                    downloadTask = new DownloadTask(listener);
                    downloadTask.execute(downloadUrl);
                    //为了让这个下载服务成为一个前台服务，还调用了startForeground()方法，这样就会在系统状态栏中创建一个持续运行的通知了。
                    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();
                }
                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 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.setSmallIcon(R.mipmap.ic_launcher);
            builder.setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher));
            builder.setContentIntent(pendingIntent);
            builder.setContentTitle(title);
            if (progress >=0 ) {
                //当progress 大于或等于0时才需要显示下载进度
                builder.setContentText(progress + "%");
                //setProgress()方法接收3个参数，第一个参数传入通知的最大进度，第二个参数传入通知的当前进度，第三个参数表示是否使用模糊进度条，这里传入false。
                //设置完setProgress()方法，通知上就会有进度条显示出来了。
                builder.setProgress(100,progress,false);
            }
            return builder.build();
        }
    }

现在下载的服务也已经成功实现，后端的工作基本都完成了，那么接下来我们开始编写前端的部分。修改activity\_main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/start_download"
            android:text="Start Download"/>
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/pause_download"
            android:text="Pause Download"/>
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/cancel_download"
            android:text="Cancel Download"/>
    </LinearLayout>

在LinearLayout中放置了3个按钮，分别用于开始下载、暂停下载和取消下载。然后修改MainActivity中的代码，如下所示：

package com.zhouzhou.servicebestpractice;
    
    import androidx.annotation.NonNull;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.app.ActivityCompat;
    import androidx.core.content.ContextCompat;
    
    import android.Manifest;
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener {
        private DownloadService.DownloadBinder downloadBinder;
        //首先创建了一个ServiceConnection的匿名类，然后在onServiceConnected()方法中获取到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_main);
            //对各个按钮都进行了初始化操作并设置了点击事件
            Button startDownload = (Button) findViewById(R.id.start_download);
            Button pauseDownload = (Button) findViewById(R.id.pause_download);
            Button cancelDownload = (Button) findViewById(R.id.cancel_download);
            startDownload.setOnClickListener(this);
            pauseDownload.setOnClickListener(this);
            cancelDownload.setOnClickListener(this);
            Intent intent = new Intent(this,DownloadService.class);
            //分别调用了startService()和bindService()方法来启动和绑定服务。
            //这一点至关重要，因为启动服务可以保证DownloadService一直在后台运行，
            //绑定服务则可以让MainActivity和DownloadService进行通信，因此两个方法调用都必不可少。
            startService(intent);//启动服务
            bindService(intent,connection,BIND_AUTO_CREATE);//绑定服务
            //进行了WRITE_EXTERNAL_STORAGE的运行时权限申请，
            //因为下载文件是要下载到SD卡的Download目录下的，如果没有这个权限的话，整个程序都无法正常工作。
            if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(MainActivity.this,new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
            }
        }
        @Override
        public void onClick(View view) {
            if (downloadBinder == null) {
                return;
            }
            switch (view.getId()) {
                case R.id.start_download:
                    //别整太小的文件，不然进度条0%，刷的一下就下载完了。看不到进入条慢慢增长的状态。哈哈
                    String url = "https://raw.githubusercontent.com/guolindev/eclipse/master/eclipse-inst-win64.exe";
                    downloadBinder.startDownload(url);
                    break;
                case R.id.pause_download:
                    downloadBinder.pauseDownload();
                    break;
                case R.id.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();
                        finish();
                    }
                    break;
                default:
            }
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //需要注意，如果活动被销毁了，那么一定要记得对服务进行解绑，不然就有可能会造成内存泄漏。
            unbindService(connection);
        }
    }

只差最后一步了，还需要在AndroidManifest.xml文件中声明使用到的权限。当然除了权限之外，MainActivity和DownloadService也是需要声明的，不过Android Studio应该早就帮我们将这两个组件声明好了，如下所示：

除此之外我们还要添加运行前台的权限（安卓9.0之后）

> <uses-permission android:name="android.permission.FOREGROUND\_SERVICE"/>

运行程序，仍然可能报错：android.app.RemoteServiceException: Bad notification for startForeground

原因：安卓版本问题，在Android8.0以上的的通知要设置渠道，否则就无法显示。

解决办法：修改DownloadService类中的getNotification()方法

private Notification getNotification(String title,int progress){
        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pi = PendingIntent.getActivity(this,0,intent,0);
        NotificationManager manager =                 
            (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
        NotificationCompat.Builder notification;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                String channelId = "default";
                String channelName = "默认通知";
                manager.createNotificationChannel(new NotificationChannel(channelId, 
                    channelName, NotificationManager.IMPORTANCE_HIGH));
        }
        notification = new NotificationCompat.Builder(DownloadService.this,"default")
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setLargeIcon(BitmapFactory.decodeResource(getResources(),
                        R.mipmap.ic_launcher))
                    .setContentIntent(pi)
                    .setContentTitle(title);
        if(progress>=0){
            //当progress大于等于0时才需要显示下载进度
            notification.setContentText(progress + "%");
            notification.setProgress(100,progress,false);
        }
        return notification.build();
    }

修改后运行程序，如果出现这个报错：D/NetworkSecurityConfig: No Network Security Config specified, using platform default

解决办法：

首先给app添加网络访问权限

> <uses-permission android:name="android.permission.ACCESS\_WIFI\_STATE"/>  
> <uses-permission android:name="android.permission.ACCESS\_NETWORK\_STATE"/>

新建 network\_security\_config.xml，路径为res/xml/network\_security\_config.xml

<?xml version="1.0" encoding="utf-8"?>
        <network-security-config>
            <domain-config>
                <domain includeSubdomains="true">example.com</domain>
                <pin-set expiration="2018-01-01">
                    <pin digest="SHA-256">7HIpactkIAq2Y49orFOOQKurWxmmSFZhBCoQYcRhJ3Y=</pin>
                    
                    <pin digest="SHA-256">fwza0LRMXouZHRC8Ei+4PyuldPDcf3UKgO/04cDM1oE=</pin>
                </pin-set>
            </domain-config>
        </network-security-config>

在AndroidManifest.xml中添加

此时再运行程序，成功运行下载示例。

tip：如果没有科学上网工具。当网速较慢时，可以尝试该[链接][Link 1]（钉钉的apk，大小为5m）测试

[Link 1]: https://dtapp-pub.dingtalk.com/dingtalk-desktop/win_downloader/dingtalk_downloader.exe%C2%A0