应用更新是每个app都会有的功能模块，而文件下载在App中也经常有需要它的地方，比如我自己，公司的项目需要查看合同，所以需要先下载到本地。所以，基于这些需求，觉得需要有封装的必要性。 实际上Android中已经提供了一个DownloadManager类来实现的下载的功能，起初我也打算基于它进行封装，但是网上说某些机型的系统中已经被厂家删掉了。所谓万丈高楼平地起，从头开始：

1. DownloadManager类：基于OkHttp实现下载功能

a) 添加OkHttp的依赖：

compile 'com.squareup.okhttp3:okhttp:3.9.0'

b) 新建一个回调接口DownloadCallBack：

public interface DownloadCallBack {

/**
 * 下载成功的回调
 *
 * @param filename
 */
void onComplete(String filename);

/**
 * 下载失败的回调
 *
 * @param t
 */
void onError(Throwable t);

/**
 * 进度更新的回调
 *
 * @param filename
 * @param percent
 */
void onProgress(String filename, int percent);
}

c) 然后就是DownloadManager类的实现：

public class DownloadManager {

    private DownloadCallBack mDownloadCallBack;
    private int lastProgress;

    public DownloadManager(DownloadCallBack callBack) {
        this.mDownloadCallBack = callBack;
    }

    /**
     * @param destDir 文件存放的目录
     * @param url     下载url
     * @param readLen 进行流操作时的字节单位数
     */
    public void download(final String destDir, final String url, final int readLen) {

        /*
         构造文件存放目录的File对象.
         */
        File file = new File(destDir);
        file.mkdirs();

        /*
        构造请求
         */
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();

        /*
        异步请求
         */
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

                InputStream is = null;
                FileOutputStream fos = null;

                try {

                    is = response.body().byteStream();

                    //熟悉的流读取和写入操作
                    byte[] buff = new byte[readLen];
                    int len;

                    long current = 0;
                    long total = response.body().contentLength();

                    fos = new FileOutputStream(destDir + getFileName(url));
                    lastProgress = 0;

                    while ((len = is.read(buff)) != -1) {
                        current += len;
                        fos.write(buff, 0, len);

                        if (mDownloadCallBack != null) {
                            //计算下载进度并回调
                            int progress = (int) (current * 100 / total);
                            if (progress > lastProgress) {
                                mDownloadCallBack.onProgress(destDir + getFileName(url), progress);
                                lastProgress = progress;
                            }
                        }
                    }

                    fos.flush();
                    response.body().close();

                    if (mDownloadCallBack != null) {
                        mDownloadCallBack.onComplete(destDir + getFileName(url));
                    }

                } catch (IOException e) {

                    if (mDownloadCallBack != null) {
                        mDownloadCallBack.onError(e);
                    }

                } finally {
                    StreamUtils.close(fos);
                    StreamUtils.close(is);
                }
            }
        });
    }

    public String getFileName(String url) {
        return url.substring(url.lastIndexOf("/"));
    }
}

三个方法：

• 构造器：接收一个DownloadCallBack的参数
• getFileName()：根据url来截取文件名并返回

• download()：下载功能的具体实现。说明三点：

  • file.mkdirs()：没有进行file是否存在的判断操作，因为发现mkdirs()方法中已经做了判断。
  • 
    
  • onResponse()：运行在子线程中

  • StreamUtils类的实现：

    public class StreamUtils {
    
        public static void close(Closeable stream) {
    
            try {
                if (stream != null) {
                    stream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

2.DownloadService类：下载服务类，负责下载动作的发起以及Notification的更新显示。代码如下：

public class DownloadService extends Service {

    private NotificationCompat.Builder mBuilder;
    private NotificationManagerCompat mNotificationManager;

    private DownloadManager mDownloadManager;

    class DownloadBinder extends Binder {

        public void startDownload(String destDir, final String url, final int readLen) {
            mDownloadManager.download(destDir, url, readLen);
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {

        initNotification();
        mDownloadManager = new DownloadManager(new DownloadCallBack() {
            @Override
            public void onComplete(String filename) {
                Log.i("TAG", "DownloadService onComplete()");
//                updateNotification(101);
                installApk(filename);
                stopSelf();
            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onProgress(String filename, int percent) {

//                if (percent > 95) {
                Log.e("TAG", "percent = " + percent);
//                }
                updateNotification(percent);

            }
        });

        return new DownloadBinder();
    }


    private void initNotification() {

        mBuilder = new NotificationCompat.Builder(this, "main")
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle("正在下载")
                .setContentText("0%");

        mNotificationManager = NotificationManagerCompat.from(this);
        mNotificationManager.notify(100, mBuilder.build());

    }

    private void updateNotification(int progress) {

        mBuilder.setProgress(100, progress, false);
        mBuilder.setContentText(progress + "%");
        mNotificationManager.notify(100, mBuilder.build());

    }

    //跳转到应用安装界面进行安装
    private void installApk(String filename) {

        File apkFile = new File(filename);
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            Uri uri = FileProvider.getUriForFile(this, "com.xlh.downloadmanager.fileProvider", apkFile);
            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            intent.setDataAndType(uri, "application/vnd.android.package-archive");
        } else {
            intent.setDataAndType(Uri.fromFile(apkFile), "application/vnd.android.package-archive");
        }

        startActivity(intent);
    }
}

唯一需要注意的地方就是：别忘了在AndroidManifest.xml进行Service注册以及适配7.0系统的FileProvider的使用：

a. 在res目录下新建xml目录，并在xml目录下新建file_paths.xml文件（文件名任意）

    <paths xmlns:android="http://schemas.android.com/apk/res/android">
      <external-path
          name="external_files"
          path="."/>
      <external-path
          name="files_root"
          path="Android/data/com/pgyersdk"/>
      <external-path
          name="external_storage_root"
          path="."/>
    </paths>

b. 在AndroidManifest.xml添加如下：

    <provider
        android:name="android.support.v4.content.FileProvider"
        android:authorities="com.xlh.downloadmanager.fileProvider"
        android:exported="false"
        android:grantUriPermissions="true">
        <meta-data
            android:name="android.support.FILE_PROVIDER_PATHS"
            android:resource="@xml/file_paths" />
    </provider>

3.UpdateManager类：应用更新的统一对外类。

public class UpdateManager {

    private static final int READ_LENGTH = 512;
    private String url;

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            DownloadService.DownloadBinder mBinder = (DownloadService.DownloadBinder) service;
            mBinder.startDownload(Environment.getExternalStorageDirectory() + "/download", url, READ_LENGTH);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    public void startDownload(Context context, final String url) {
        this.url = url;
        startAndBindService(context);
    }

    public void unregister(Context context) {

        if (conn != null) {
            context.unbindService(conn);
        }
    }

    /*------------------------------------------------------------------------*/

    private void startAndBindService(Context context) {
        Intent intent = new Intent(context, DownloadService.class);
        context.startService(intent);
        context.bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }

只需要注意一点：对于DownloadService，使用了两种方式启动了它：start方式和bind方式。这样做的好处就是：既方便了和服务进行通信，同时在退出应用时下载任务不会中断。与此同时，这样会影响Service的生命周期，既需要调用了Service的stopSelf或者Context的stopService，又需要调用Context的unbindService才能使服务停止。详情可见官方文档的相关描述，这里就不贴了。

4.编写MainActivity，进行功能测试：

a) 布局文件的编写：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.dc3658.download.MainActivity">

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="download"
        android:text="开始下载" />

</LinearLayout>

b. MainActivity的实现：

    class MainActivity : AppCompatActivity() {

        private val manager = UpdateManager()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        MPermissionUtils.onRequestPermissionsResult(requestCode, permissions, grantResults)
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    }

    override fun onDestroy() {
        super.onDestroy()
        manager.unregister(this)
    }


    fun download(view: View) {

        MPermissionUtils.requestPermissionsResult(this, 100, arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE), object : MPermissionUtils.OnPermissionListener {

            override fun onPermissionGranted() {
                manager.startDownload(this@MainActivity, "xxxxxxxxxxxxxxxx")
            }

            override fun onPermissionDenied() {

            }
        })

    }

}

• 这里使用了鸿洋大神的MPermissionUtils来适配6.0动态权限：

  public class MPermissionUtils {
  
      private static int mRequestCode = -1;
  
      public static void requestPermissionsResult(Activity activity, int requestCode
              , String[] permission, OnPermissionListener callback) {
          requestPermissions(activity, requestCode, permission, callback);
      }
  
      public static void requestPermissionsResult(android.app.Fragment fragment, int requestCode
              , String[] permission, OnPermissionListener callback) {
          requestPermissions(fragment, requestCode, permission, callback);
      }
  
      public static void requestPermissionsResult(android.support.v4.app.Fragment fragment, int requestCode
              , String[] permission, OnPermissionListener callback) {
          requestPermissions(fragment, requestCode, permission, callback);
      }
  
      /**
       * 请求权限处理
       *
       * @param object      activity or fragment
       * @param requestCode 请求码
       * @param permissions 需要请求的权限
       * @param callback    结果回调
       */
      @TargetApi(Build.VERSION_CODES.M)
      private static void requestPermissions(Object object, int requestCode
              , String[] permissions, OnPermissionListener callback) {
  
          checkCallingObjectSuitability(object);
          mOnPermissionListener = callback;
  
          if (checkPermissions(getContext(object), permissions)) {
              if (mOnPermissionListener != null)
                  mOnPermissionListener.onPermissionGranted();
          } else {
              List<String> deniedPermissions = getDeniedPermissions(getContext(object), permissions);
              if (deniedPermissions.size() > 0) {
                  mRequestCode = requestCode;
                  if (object instanceof Activity) {
                      ((Activity) object).requestPermissions(deniedPermissions
                              .toArray(new String[deniedPermissions.size()]), requestCode);
                  } else if (object instanceof android.app.Fragment) {
                      ((android.app.Fragment) object).requestPermissions(deniedPermissions
                              .toArray(new String[deniedPermissions.size()]), requestCode);
                  } else if (object instanceof android.support.v4.app.Fragment) {
                      ((android.support.v4.app.Fragment) object).requestPermissions(deniedPermissions
                              .toArray(new String[deniedPermissions.size()]), requestCode);
                  } else {
                      mRequestCode = -1;
                  }
              }
          }
      }
  
      /**
       * 获取上下文
       */
      private static Context getContext(Object object) {
          Context context;
          if (object instanceof android.app.Fragment) {
              context = ((android.app.Fragment) object).getActivity();
          } else if (object instanceof android.support.v4.app.Fragment) {
              context = ((android.support.v4.app.Fragment) object).getActivity();
          } else {
              context = (Activity) object;
          }
          return context;
      }
  
      /**
       * 请求权限结果，对应onRequestPermissionsResult()方法。
       */
      public static void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
          if (mRequestCode != -1 && requestCode == mRequestCode) {
              if (verifyPermissions(grantResults)) {
                  if (mOnPermissionListener != null)
                      mOnPermissionListener.onPermissionGranted();
              } else {
                  if (mOnPermissionListener != null)
                      mOnPermissionListener.onPermissionDenied();
              }
          }
      }
  
      /**
       * 显示提示对话框
       */
      public static void showTipsDialog(final Context context) {
          new AlertDialog.Builder(context)
                  .setTitle("提示信息")
                  .setMessage("当前应用缺少必要权限，该功能暂时无法使用。如若需要，请单击【确定】按钮前往设置中心进行权限授权。")
                  .setNegativeButton("取消", null)
                  .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                      @Override
                      public void onClick(DialogInterface dialog, int which) {
                          startAppSettings(context);
                      }
                  }).show();
      }
  
      /**
       * 启动当前应用设置页面
       */
      private static void startAppSettings(Context context) {
          Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
          intent.setData(Uri.parse("package:" + context.getPackageName()));
          context.startActivity(intent);
      }
  
      /**
       * 验证权限是否都已经授权
       */
      private static boolean verifyPermissions(int[] grantResults) {
          for (int grantResult : grantResults) {
              if (grantResult != PackageManager.PERMISSION_GRANTED) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * 获取权限列表中所有需要授权的权限
       *
       * @param context     上下文
       * @param permissions 权限列表
       * @return
       */
      private static List<String> getDeniedPermissions(Context context, String... permissions) {
          List<String> deniedPermissions = new ArrayList<>();
          for (String permission : permissions) {
              if (ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_DENIED) {
                  deniedPermissions.add(permission);
              }
          }
          return deniedPermissions;
      }
  
      /**
       * 检查所传递对象的正确性
       *
       * @param object 必须为 activity or fragment
       */
      private static void checkCallingObjectSuitability(Object object) {
          if (object == null) {
              throw new NullPointerException("Activity or Fragment should not be null");
          }
  
          boolean isActivity = object instanceof Activity;
          boolean isSupportFragment = object instanceof android.support.v4.app.Fragment;
          boolean isAppFragment = object instanceof android.app.Fragment;
  
          if (!(isActivity || isSupportFragment || isAppFragment)) {
              throw new IllegalArgumentException(
                      "Caller must be an Activity or a Fragment");
          }
      }
  
      /**
       * 检查所有的权限是否已经被授权
       *
       * @param permissions 权限列表
       * @return
       */
      private static boolean checkPermissions(Context context, String... permissions) {
          if (isOverMarshmallow()) {
              for (String permission : permissions) {
                  if (ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_DENIED) {
                      return false;
                  }
              }
          }
          return true;
      }
  
      /**
       * 判断当前手机API版本是否 >= 6.0
       */
      private static boolean isOverMarshmallow() {
          return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
      }
  
      public interface OnPermissionListener {
          void onPermissionGranted();
  
          void onPermissionDenied();
      }
  
      private static OnPermissionListener mOnPermissionListener;
  
  }
  

• 在onDestroy回调中进行解除Service绑定
• kotlin语言，应该都好懂，只有this@MainActivity表示外部类的对象，同MainActivity.this以及匿名内部类的实现形式：通过object关键字

系列一就到这里了，在后面的系列文章中我们继续完善。谢谢大家的阅读~

代码已上传到GitHub：DownloadManager。后期代码会更新，如果需要这版的源码，可以通过如下操作：

1. 执行git log 命令：

找到日志信息为step one的，记录下step one上面的commit id，这里就是67d98e......

2. 执行git reset --hard 67d98e，如果显示HEAD is now at  ...就表示版本回退成功，就能拿到此版本的代码啦~