android 多线程断点续传下载 二

最新推荐文章于 2024-04-08 09:45:15 发布
最新推荐文章于 2024-04-08 09:45:15 发布
阅读量796 收藏
点赞数
分类专栏： Android学习笔记

在上一集中,我们简单介绍了如何创建多任务下载,但那种还不能拿来实用,这一集我们重点通过代码为大家展示如何创建多线程断点续传下载,这在实际项目中很常用.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
	<EditText
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:id="@+id/editText"
		android:text="http://gongxue.cn/yingyinkuaiche/UploadFiles_9323/201008/2010082909434077.mp3"
	/>
	<LinearLayout
		android:orientation="horizontal"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
	>
		<Button
			android:layout_width="wrap_content"
			android:layout_height="wrap_content"
			android:id="@+id/downButton"
			android:text="Download"
		/>
		<Button
			android:layout_width="wrap_content"
			android:layout_height="wrap_content"
			android:id="@+id/pauseButton"
			android:enabled="false"
			android:text="Pause"
		/>
	</LinearLayout>
	
	<ProgressBar
		android:layout_width="match_parent"
		android:layout_height="18dp"
		style="?android:attr/progressBarStyleHorizontal"
		android:id="@+id/progressBar"
	/>
	<TextView
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:id="@+id/textView"
		android:gravity="center"
	/>
</LinearLayout>

String.xml: 

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Main!</string>
    <string name="app_name">多线程断点续传下载</string>
</resources>

AndroidManifest.xml: 

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="sms.multithreaddownload"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".Main"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
	 <uses-library android:name="android.test.runner" />
    </application>
    <uses-sdk android:minSdkVersion="8" />
    <instrumentation
        android:targetPackage="sms.multithreaddownload"
        android:name="android.test.InstrumentationTestRunner" />
    <!-- 访问网络的权限 -->
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- SDCard写数据的权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    

</manifest>

activity程序: 

package sms.multithreaddownload;

import java.io.File;

import sms.multithreaddownload.bean.DownloadListener;
import sms.multithreaddownload.service.DownloadService;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class Main extends Activity {
	private EditText path;
	private TextView progress;
	private ProgressBar progressBar;
	private Handler handler = new UIHandler();
	private DownloadService servcie;
	private Button downButton;
	private Button pauseButton;

	private final class UIHandler extends Handler {
		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
				case 1:
					int downloaded_size = msg.getData().getInt("size");
					progressBar.setProgress(downloaded_size);
					int result = (int) ((float) downloaded_size / progressBar.getMax() * 100);
					progress.setText(result + "%");
					if (progressBar.getMax() == progressBar.getProgress()) {
						Toast.makeText(getApplicationContext(), "下载完成", Toast.LENGTH_LONG).show();
					}
			}
		}
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		path = (EditText) this.findViewById(R.id.editText);
		progress = (TextView) this.findViewById(R.id.textView);
		progressBar = (ProgressBar) this.findViewById(R.id.progressBar);
		downButton = (Button) this.findViewById(R.id.downButton);
		pauseButton = (Button) this.findViewById(R.id.pauseButton);
		downButton.setOnClickListener(new DownloadButton());
		pauseButton.setOnClickListener(new PauseButton());
	}

	private final class DownloadButton implements View.OnClickListener {
		@Override
		public void onClick(View v) {
			DownloadTask task;
			try {
				task = new DownloadTask(path.getText().toString());
				servcie.isPause = false;
				v.setEnabled(false);
				pauseButton.setEnabled(true);
				new Thread(task).start();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public class PauseButton implements OnClickListener {
		@Override
		public void onClick(View v) {
			servcie.isPause = true;
			v.setEnabled(false);
			downButton.setEnabled(true);
		}
	}

	public void pause(View v) {
	}

	private final class DownloadTask implements Runnable {

		public DownloadTask(String target) throws Exception {
			if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
				File destination = Environment.getExternalStorageDirectory();
				servcie = new DownloadService(target, destination, 3, getApplicationContext());
				progressBar.setMax(servcie.fileSize);
			} else {
				Toast.makeText(getApplicationContext(), "SD卡不存在或写保护!", Toast.LENGTH_LONG).show();
			}
		}

		@Override
		public void run() {
			try {
				servcie.download(new DownloadListener() {

					@Override
					public void onDownload(int downloaded_size) {
						Message message = new Message();
						message.what = 1;
						message.getData().putInt("size", downloaded_size);
						handler.sendMessage(message);
					}

				});
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
	}
}
工具类 

package sms.multithreaddownload.bean;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DBHelper extends SQLiteOpenHelper {

	public DBHelper(Context context) {
		super(context, "MultiDownLoad.db", null, 1);
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL("CREATE TABLE fileDownloading(_id integer primary key autoincrement,downPath varchar(100),threadId INTEGER,downLength INTEGER)");
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		// TODO Auto-generated method stub

	}

}


package sms.multithreaddownload.bean;

public interface DownloadListener {
	public void onDownload(int downloaded_size);
}


package sms.multithreaddownload.bean;

import java.io.File;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

import sms.multithreaddownload.service.DownloadService;

import android.util.Log;

public final class MultiThreadDownload implements Runnable {
	public int id;
	private RandomAccessFile savedFile;
	private String path;
	/* 当前已下载量 */
	public int currentDownloadSize = 0;
	/* 下载状态 */
	public boolean finished;
	/* 用于监视下载状态 */
	private final DownloadService downloadService;
	/* 线程下载任务的起始点 */
	public int start;
	/* 线程下载任务的结束点 */
	private int end;

	public MultiThreadDownload(int id, File savedFile, int block, String path, Integer downlength, DownloadService downloadService) throws Exception {
		this.id = id;
		this.path = path;
		if (downlength != null) this.currentDownloadSize = downlength;
		this.savedFile = new RandomAccessFile(savedFile, "rwd");
		this.downloadService = downloadService;
		start = id * block + currentDownloadSize;
		end = (id + 1) * block;
	}

	@Override
	public void run() {
		try {
			HttpURLConnection conn = (HttpURLConnection) new URL(path).openConnection();
			conn.setConnectTimeout(5000);
			conn.setRequestMethod("GET");
			conn.setRequestProperty("Range", "bytes=" + start + "-" + end); // 设置获取数据的范围

			InputStream in = conn.getInputStream();
			byte[] buffer = new byte[1024];
			int len = 0;
			savedFile.seek(start);
			while (!downloadService.isPause && (len = in.read(buffer)) != -1) {
				savedFile.write(buffer, 0, len);
				currentDownloadSize += len;
			}
			savedFile.close();
			in.close();
			conn.disconnect();
			if (!downloadService.isPause) Log.i(DownloadService.TAG, "Thread " + (this.id + 1) + "finished");
			finished = true;
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("File downloading error!");
		}
	}
}

service类: 
package sms.multithreaddownload.service;

import java.io.File;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import sms.multithreaddownload.bean.DBHelper;
import sms.multithreaddownload.bean.DownloadListener;
import sms.multithreaddownload.bean.MultiThreadDownload;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;


public class DownloadService {
	public static final String TAG = "tag";
	/* 用于查询数据库 */
	private DBHelper dbHelper;
	/* 要下载的文件大小 */
	public int fileSize;
	/* 每条线程需要下载的数据量 */
	private int block;
	/* 保存文件地目录 */
	private File savedFile;
	/* 下载地址 */
	private String path;
	/* 是否停止下载 */
	public boolean isPause;
	/* 线程数 */
	private MultiThreadDownload[] threads;
	/* 各线程已经下载的数据量 */
	private Map<Integer, Integer> downloadedLength = new ConcurrentHashMap<Integer, Integer>();

	public DownloadService(String target, File destination, int thread_size, Context context) throws Exception {
		dbHelper = new DBHelper(context);
		this.threads = new MultiThreadDownload[thread_size];
		this.path = target;
		URL url = new URL(target);
		HttpURLConnection conn = (HttpURLConnection) url.openConnection();
		conn.setConnectTimeout(5000);
		conn.setRequestMethod("GET");

		if (conn.getResponseCode() != 200) {
			throw new RuntimeException("server no response!");
		}

		fileSize = conn.getContentLength();
		if (fileSize <= 0) {
			throw new RuntimeException("file is incorrect!");
		}
		String fileName = getFileName(conn);
		if (!destination.exists()) destination.mkdirs();
		// 构建一个同样大小的文件
		this.savedFile = new File(destination, fileName);
		RandomAccessFile doOut = new RandomAccessFile(savedFile, "rwd");
		doOut.setLength(fileSize);
		doOut.close();
		conn.disconnect();

		// 计算每条线程需要下载的数据长度
		this.block = fileSize % thread_size == 0 ? fileSize / thread_size : fileSize / thread_size + 1;
		// 查询已经下载的记录
		downloadedLength = this.getDownloadedLength(path);
	}

	private Map<Integer, Integer> getDownloadedLength(String path) {
		SQLiteDatabase db = dbHelper.getReadableDatabase();
		String sql = "SELECT threadId,downLength FROM fileDownloading WHERE downPath=?";
		Cursor cursor = db.rawQuery(sql, new String[] { path });
		Map<Integer, Integer> data = new HashMap<Integer, Integer>();
		while (cursor.moveToNext()) {
			data.put(cursor.getInt(0), cursor.getInt(1));
		}
		db.close();
		return data;
	}

	private String getFileName(HttpURLConnection conn) {
		String fileName = path.substring(path.lastIndexOf("/") + 1, path.length());
		if (fileName == null || "".equals(fileName.trim())) {
			String content_disposition = null;
			for (Entry<String, List<String>> entry : conn.getHeaderFields().entrySet()) {
				if ("content-disposition".equalsIgnoreCase(entry.getKey())) {
					content_disposition = entry.getValue().toString();
				}
			}
			try {
				Matcher matcher = Pattern.compile(".*filename=(.*)").matcher(content_disposition);
				if (matcher.find()) fileName = matcher.group(1);
			} catch (Exception e) {
				fileName = UUID.randomUUID().toString() + ".tmp"; // 默认名
			}
		}
		return fileName;
	}

	public void download(DownloadListener listener) throws Exception {
		this.deleteDownloading(); // 先删除上次的记录,再重新添加
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new MultiThreadDownload(i, savedFile, block, path, downloadedLength.get(i), this);
			new Thread(threads[i]).start();
		}
		this.saveDownloading(threads);

		while (!isFinish(threads)) {
			Thread.sleep(900);
			if (listener != null) listener.onDownload(getDownloadedSize(threads));
			this.updateDownloading(threads);
		}
		if (!this.isPause) this.deleteDownloading();// 完成下载之后删除本次下载记录
	}

	private void saveDownloading(MultiThreadDownload[] threads) {
		SQLiteDatabase db = dbHelper.getWritableDatabase();
		try {
			db.beginTransaction();
			for (MultiThreadDownload thread : threads) {
				String sql = "INSERT INTO fileDownloading(downPath,threadId,downLength) values(?,?,?)";
				db.execSQL(sql, new Object[] { path, thread.id, 0 });
			}
			db.setTransactionSuccessful();
		} finally {
			db.endTransaction();
			db.close();
		}
	}

	private void deleteDownloading() {
		SQLiteDatabase db = dbHelper.getWritableDatabase();
		String sql = "DELETE FROM fileDownloading WHERE downPath=?";
		db.execSQL(sql, new Object[] { path });
		db.close();
	}

	private void updateDownloading(MultiThreadDownload[] threads) {
		SQLiteDatabase db = dbHelper.getWritableDatabase();
		try {
			db.beginTransaction();
			for (MultiThreadDownload thread : threads) {
				String sql = "UPDATE fileDownloading SET downLength=? WHERE threadId=? AND downPath=?";
				db.execSQL(sql, new String[] { thread.currentDownloadSize + "", thread.id + "", path });
			}
			db.setTransactionSuccessful();
		} finally {
			db.endTransaction();
			db.close();
		}
	}

	private int getDownloadedSize(MultiThreadDownload[] threads) {
		int sum = 0;
		for (int len = threads.length, i = 0; i < len; i++) {
			sum += threads[i].currentDownloadSize;
		}
		return sum;
	}

	private boolean isFinish(MultiThreadDownload[] threads) {
		try {
			for (int len = threads.length, i = 0; i < len; i++) {
				if (!threads[i].finished) {
					return false;
				}
			}
			return true;
		} catch (Exception e) {
			return false;
		}
	}
}



源码下载

Mcins
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DownloadManager之DownloadService浅析
weixin_33797791的博客
03-20 963
2019独角兽企业重金招聘Python工程师标准>>> ...
Android多线程断点续传下载原理及实现，移动开发工程师简历
m0_64604842的博客
12-19 777
RandomAccessFile 文件写入 下面再讲讲文件写入问题，由于我们是多线程下载，因此文件并不是每次都是从前往后一个个字节写入的，随时可能在文件的任何一个地方写入数据。因此我们需要能够在文件的指定位置写入数据。这里我们用到了RandomAccessFile 来实现这个功能。 RandomAccessFile 是一个随机访问文件类，同时整合了 FileOutputStream 和 FileInputStream，支持从文件的任何字节处读写数据。通过它我们就可以在文件的任何字节处写入数据。 接下来简单讲
探秘Dpuntu的Android Downloader：一款高效、灵活的Android资源下载工具
最新发布
gitblog_00040的博客
04-08 305
探秘Dpuntu的Android Downloader：一款高效、灵活的Android资源下载工具 项目地址:https://gitcode.com/Dpuntu/android-downloader 在Android开发中，资源的下载管理是一个必不可少的部分，而Dpuntu带来的Android Downloader正是为此目的打造的一款强大且易用的工具。本文将深入探讨其功能、技术实现和应用场景，...
Android多线程断点续传下载原理及实现，渣本二面阿里受挫
m0_66264134的博客
01-22 721
首先，我们定义一下下载中的各个状态： public class DownloadStatus { public static final int IDLE = 233; // 空闲，默认状态 public static final int COMPLETED = 234; // 完成 public static final int DOWNLOADING = 235; // 下载中 public static final int PAUSE = 23
Android基础篇-多线程断点下载（三）
王涛的博客
11-21 1151
效果图： Log: 网上关于讲解挺多的，我这里不讲解了，不懂的可以评论留言，从问题中解决问题 我可以说一下我解决问题的方式，将复杂问题划分成多个简单的问题多线程下载一：请点击这里多线程下载二：请点击这里权限： <uses-permission android:name="android.permission.INTERNET"></uses-permission> <uses-perm
Android多线程断点续传下载示例详解
01-20
在上一篇博文《Android多线程下载示例》中，我们讲解了如何实现Android的多线程下载功能，通过将整个文件分成多个数据块，开启多个线程，让每个线程分别下载一个相应的数据块来实现多线程下载的功能。多线程下载中，...
Android实现网络多线程断点续传下载功能
08-31
在Android开发中，实现网络多线程断点续传下载是一项重要的技能，它能显著提高大文件下载的效率，提供更好的用户体验。以下是对这个主题的详细解析： 首先，要理解多线程下载的基本思想。传统的单线程下载方式可能...
Android FTP 多线程断点续传下载\上传的实例
08-29
本文将详细介绍如何在Android环境中实现FTP的多线程断点续传下载和上传功能，以及在实现过程中需要注意的关键点。 FTP下载原理： FTP协议不同于HTTP协议，它没有HTTP中的头文件来指定下载范围。然而，FTP提供了REST...
android实现多线程断点续传功能
08-28
Android 实现多线程断点续传功能是指在 Android 平台上使用多线程技术来实现断点续传功能，断点续传是指在下载或上传文件的过程中，能够从上一次断点处继续下载或上传，从而提高下载或上传的效率和速度。 在 ...
Android多线程文件夹下载及断点续传
08-07
在实现多线程下载和断点续传时，还需要注意以下几点： - **异常处理**：网络中断、文件I/O错误等异常情况需要妥善处理，确保能够恢复下载。 - **线程同步**：在多线程环境下，需要确保线程安全，防止数据竞争和不...
详解Android使用OKHttp3实现下载(断点续传、显示进度)
01-04
OKHttp3是如今非常流行的Android网络请求框架,那么如何利用Android实现断点续传呢,今天写了个Demo尝试了一下,感觉还是有点意思 准备阶段 我们会用到OKHttp3来做网络请求,使用RxJava来实现线程的切换,并且开启Java8来启用Lambda表达式,毕竟RxJava实现线程切换非常方便,而且数据流的形式也非常舒服,同时Lambda和RxJava配合食用味道更佳 打开我们的app Module下的build.gradle,代码如下 apply plugin: 'com.android.application' android { compileSdkVer
Android文件断点下载案例
02-19
实现文件的断点下载，继续，暂停，重新下载
Android 多线程图片下载开源代码
03-30
NULL 博文链接：https://chaoting04-gmail-com.iteye.com/blog/1310307
android多线程断点续传
05-07
android多线程断点续传 android多线程断点续传 android多线程断点续传
Android多线程下载实现方案
06-11
使用多线程技术实现文件的下载,断点续传等功能,内置demo.apk,可以直接安装进行体验
Android之断点续传下载（转）
iteye_14850的博客
11-11 96
  原文链接     在我们做开发的时候经常遇到的就是下载了，现在下载的方法有很多很多，那么怎么做到断点续传下载呢！很多人都头疼这个问题，如果我们没有很好的逻辑真不是很容易解决啊。我参考了一下前辈们的资料了整理了一个项目，能实现多个文件的同时下载。      断点续传下载，顾名思义，那就是我们在一次下载未结束时，退出下载，第二次下载时会接着第一次下载的进度继续下载。那么怎么记录第一次下...
DownloadService
11-05
Activity启动Service，并交互，后台下载，并更新带有进度条的状态栏。
android多线程下载代码
06-20
// 声明控件 // 路径与线程数量 private EditText et_url, et_num; // 进度条 public static ProgressBar pb_thread; // 显示进度的操作 private TextView tv_pb; // 线程的数量 public static int threadNum = 3; // 每个线程负责下载的大小 public int blockSize; public static int threadCount;// 数量 // 访问的path public String path; public static boolean flag = true; // 记录进度条的值 public static int pb_count = 0; public static Handler handler;
android实现下载，断点续传等
01-04
本人收集的关于安卓实现下载，断点续传和进度显示等代码，希望能帮助有需要的朋友

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值