Android 实现断点续传

最新推荐文章于 2024-05-02 20:40:27 发布
最新推荐文章于 2024-05-02 20:40:27 发布
阅读量519 收藏
点赞数
分类专栏： android 文章标签： android

来自：http://www.2cto.com/kf/201401/269891.html


断点续传：

断点续传指的是在 下载 或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传下载以后未上传下载的部分，而没有必要从头开始上传下载。用途可以节省时间，提高速度。
测试服务器是否支持断点续传的方法：

浏览器测试：

看看某个请求的响应头信息里面是否包含：
Accept-Ranges bytes
比如请求hao123，相应头信息里面包含：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Accept-Ranges bytes
Cache-Control max-age= 0
Content-Encoding gzip
Content-Length 59107
Content-Type text/html;charset=UTF- 8
Date Fri, 03 Jan 2014 02 : 40 : 27 GMT
Etag "1946829081"
Expires Fri, 03 Jan 2014 02 : 40 : 27 GMT
LFY cq01. 13
Last-Modified Fri, 03 Jan 2014 02 : 40 : 00 GMT
SFY cq01. 14
Server BWS/ 1.0
Set-Cookie hz= 0 ; path=/; domain=www.hao123.com
Vary Accept-Encoding

表明支持断点续传

curl测试：

curl –-range 100-200 http://192.168.9.155/johnny/testzip.zip > download_1
看下载文件的大小是否是100字节。
如果服务器支持断点续传，那么在请求头信息里面加上属性就可以了：
RANGE: bytes=1000-

这一行就是告诉服务器这个文件从1000字节开始传，前面就不要传了。

Java代码实现：

DownLoaderTask.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
package com.johnny.testdownloadbreakpoint;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
 
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.DialogInterface.OnClickListener;
import android.os.AsyncTask;
import android.util.Log;
 
public class DownLoaderTask extends AsyncTask< void , integer,= "" long = "" > {
     private final String TAG = "DownLoaderTask" ;
     private URL mUrl;
     private File mFile;
     private ProgressDialog mDialog;
     private int mProgress = 0 ;
     private ProgressReportingOutputStream mOutputStream;
     private Context mContext;
     public DownLoaderTask(String url,String out,Context context){
         super ();
         if (context!= null ){
             mDialog = new ProgressDialog(context);
             mContext = context;
         }
         else {
             mDialog = null ;
         }
         
         try {
             mUrl = new URL(url);
             String fileName = new File(mUrl.getFile()).getName();
             mFile = new File(out, fileName);
             Log.d(TAG, "out=" +out+ ", name=" +fileName+ ",mUrl.getFile()=" +mUrl.getFile());
         } catch (MalformedURLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         
     }
     
     @Override
     protected void onPreExecute() {
         // TODO Auto-generated method stub
         //super.onPreExecute();
         if (mDialog!= null ){
             mDialog.setTitle( "Downloading..." );
             mDialog.setMessage(mFile.getName());
             mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
             mDialog.setOnCancelListener( new OnCancelListener() {
                 
                 @Override
                 public void onCancel(DialogInterface dialog) {
                     // TODO Auto-generated method stub
                     cancel( true );
                 }
             });
             mDialog.show();
         }
     }
 
     @Override
     protected Long doInBackground(Void... params) {
         // TODO Auto-generated method stub
         if (!checkURL()){
             Log.e(TAG, "url can not access....." );
             return 0l;
         }
         return download();
     }
 
     @Override
     protected void onProgressUpdate(Integer... values) {
         // TODO Auto-generated method stub
         //super.onProgressUpdate(values);
         if (mDialog== null )
             return ;
         if (values.length> 1 ){
             int contentLength = values[ 1 ];
             if (contentLength==- 1 ){
                 mDialog.setIndeterminate( true );
             }
             else {
                 mDialog.setMax(contentLength);
             }
         }
         else {
             mDialog.setProgress(values[ 0 ].intValue());
         }
     }
 
     @Override
     protected void onPostExecute(Long result) {
         // TODO Auto-generated method stub
         //super.onPostExecute(result);
         if (mDialog!= null &&mDialog.isShowing()){
             mDialog.dismiss();
         }
         if (isCancelled())
             return ;
     }
 
     private long download(){
         URLConnection connection = null ;
         int bytesCopied = 0 ;
         try {
             connection = mUrl.openConnection();
             int length = connection.getContentLength();
             if (mFile.exists()&&length == mFile.length()){
                 Log.d(TAG, "file " +mFile.getName()+ " already exits!!" );
                 return 0l;
             }
             else if (mFile.exists()&&length > mFile.length()){
                 Log.d(TAG, "Downdoad from breakpoint : size is = " +mFile.length()+ ", total is " +length);
                 publishProgress( 0 ,length);
                 mProgress=( int ) mFile.length();
                 URLConnection connection1=mUrl.openConnection();
                 connection1.setRequestProperty( "RANGE" , "bytes=" + mFile.length() + "-" );
                 bytesCopied=copyFromBreakPoint(connection1.getInputStream(),mFile);
                 if (bytesCopied!=length&&length!=- 1 ){
                     Log.d(TAG, "Download incomplete bytesCopied=" +mFile.length()+ ", length" +length);
                 }
             }
             else if (!mFile.exists()){
                 mOutputStream = new ProgressReportingOutputStream(mFile);
                 publishProgress( 0 ,length);
                 bytesCopied =copy(connection.getInputStream(),mOutputStream);
                 if (bytesCopied!=length&&length!=- 1 ){
                     Log.d(TAG, "Download incomplete bytesCopied=" +bytesCopied+ ", length" +length);
                 }
                 mOutputStream.close();
             }
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return bytesCopied;
     }
     private int copy(InputStream input, OutputStream output){
         byte [] buffer = new byte [ 1024 * 8 ];
         BufferedInputStream in = new BufferedInputStream(input, 1024 * 8 );
         BufferedOutputStream out  = new BufferedOutputStream(output, 1024 * 8 );
         int count = 0 ,n= 0 ;
         try {
             while ((n=in.read(buffer, 0 , 1024 * 8 ))!=- 1 ){
                 out.write(buffer, 0 , n);
                 count+=n;
                 
                 if (isCancelled()){
                     Log.e(TAG, "stop downloading ....." );
                     //out.flush();
                     //out.close();
                     //in.close();
                     break ;
                 }
                 
             }
             out.flush();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } finally {
             try {
                 out.close();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             try {
                 in.close();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         return count;
     }
     private int copyFromBreakPoint(InputStream input, File output){
         byte [] buffer = new byte [ 1024 * 8 ];
         int count = 0 ,n= 0 ;
         try {
             RandomAccessFile fos = new RandomAccessFile(output, "rw" );
             
             fos.seek(output.length());
             while ( true ){
                 n=input.read(buffer);
                 if (n<= 0 ){
                     break ;
                 }
                 fos.write(buffer, 0 , n);
                 mProgress += n;
                 publishProgress(mProgress);
             }
             input.close();
             fos.close();
             
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         
         return 0 ;
     }
     private boolean checkURL(){
         boolean ret = false ;
         try {
             HttpURLConnection conn = (HttpURLConnection) mUrl.openConnection();
             if (conn.getResponseCode()== 200 )
                 ret= true ;
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return ret;
     }
     private final class ProgressReportingOutputStream extends FileOutputStream{
 
         public ProgressReportingOutputStream(File file)
                 throws FileNotFoundException {
             super (file);
             // TODO Auto-generated constructor stub
         }
 
         @Override
         public void write( byte [] buffer, int byteOffset, int byteCount)
                 throws IOException {
             // TODO Auto-generated method stub
             super .write(buffer, byteOffset, byteCount);
             mProgress += byteCount;
             publishProgress(mProgress);
         }
         
     }
}</ void ,>

MainActivity.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.johnny.testdownloadbreakpoint;
 
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
 
public class MainActivity extends Activity {
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         doDownLoadWork();
     }
 
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         // Inflate the menu; this adds items to the action bar if it is present.
         getMenuInflater().inflate(R.menu.main, menu);
         return true ;
     }
     private void doDownLoadWork(){
         DownLoaderTask task = new DownLoaderTask( "http://192.168.9.155/johnny/H264+MP3.flv" , "/storage/emulated/legacy/" , this );
         //DownLoaderTask task = new DownLoaderTask("http://192.168.9.155/johnny/test.h264", getCacheDir().getAbsolutePath()+"/", this);
         task.execute();
     }
 
}


guquan12315
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 断点续传原理以及实现
01-05
Android 断点续传原理以及实现 0.  前言 在Android开发中，断点续传听起来挺容易，在下载一个文件时点击暂停任务暂停，点击开始会继续下载文件。但是真正实现起来知识点还是蛮多的，因此今天有时间实现了一下，并进行记录。 1.  断点续传原理 在本地下载过程中要使用数据库实时存储到底存储到文件的哪个位置了，这样点击开始继续传递时，才能通过HTTP的GET请求中的setRequestProperty()方法可以告诉服务器，数据从哪里开始，到哪里结束。同时在本地的文件写入时，RandomAccessFile的seek()方法也支持在文件中的任意位置进行写入操作。同时通过广播将子线程的进度告
android 断点续传如何实现的,Android 断点续传功能的实现
weixin_36393674的博客
05-25 1224
目录实现效果按照惯例，效果奉上Kapture 2018-12-01 at 16.44.09.gif前言日更啊！日更！，上一篇比较划水的给大家分享了一下，在做这个功能时候的一点Java基础，IO流，在这个过程中顺便再讲一下另一个IO流中的RandomAccessFile类，那么今天分享一下。OKHttp依赖：使用的是OKhttp来连接网络RandomAccessFile 来进行IO的读写Broadc...
Android 断点续传实现原理
赵彦军
10-25 1117
下载原理 在介绍断点续传之前，我们先说说下载的原理。代码示例用 OkHttp 作为示例。 下载核心思路是把 responseBody 写入文件，核心代码如下： 但是这种做法有个明显的问题，假如手机在下载文件的时候下载了80%，某些原因断网了，如果不支持断点续传，那就只有被迫重头开始下载。但是如果有断点续传的加持，就只需要下载最后 20% 的资源，避免重新下载。 断点续传原理 1、java.io.RandomAccessFile 断点续传/下载需要使用到 java.io.RandomAccessFile 类
Android 编程技巧之 ----- 断点续传原理以及实现
Snow Yong
12-25 581
原文出处 ： Android开发——断点续传原理以及实现 原文作者 ： SEU_Calvin 感谢原文作者无私的分享 ! 1.  断点续传原理 在本地下载过程中要使用数据库实时存储到底存储到文件的哪个位置了，这样点击开始继续传递时，才能通过HTTP的GET请求中的setRequestProperty()方法可以告诉服务器，数据从哪里开始，到哪里结束。同时在本地的
Android断点续传原理及实现
muranfei的博客
02-16 2636
常见两种网络请求方式 一、 HttpURLConnection HttpURLConnection的setRequestProperty()方法，对我们要读取的字节部分进行控制，比如: ··· 1.Range=0-100代表只读取前100个字节。 2.Range=100-500代表读取从第100个字节开始，读到第500个字节为止。 3.Range=100-则代表从第100个字节开始读取，一直读取到文件末尾结束。 ··· 断点续传过程 1、在暂停时记录一下已经读取到的位置，在重新开始的时候利用setReque
android实现断点续传
05-05
android的断点续传，具体可以看看我博客的日志
android实现多线程断点续传功能
08-28
主要为大家详细介绍了android实现多线程断点续传功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android快速实现断点续传的方法
08-27
主要为大家详细介绍了Android快速实现断点续传的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android（Java）下载断点续传的实现
01-20
Android（Java）下载断点续传的实现一、要注意的地方1. 追加文件2. 跳过输入流3.range header坑点1.坑点2坑点3.二、代码方法1方法2 最近在做一个下载文件的功能的时候，因为要支持断点续传，虽然整体上思路很清晰，...
实现安卓文件断点续传
02-01
实现文件的断点续传功能,进行文件的双方面下载功能,实现文件的断点续传功能,简单明了
Android多线程下载实现方案
06-11
使用多线程技术实现文件的下载,断点续传等功能,内置demo.apk,可以直接安装进行体验
android实现下载，断点续传等
01-04
本人收集的关于安卓实现下载，断点续传和进度显示等代码，希望能帮助有需要的朋友
Android-使用HttpURLConnection实现断点续传
08-13
使用HttpURLConnection实现断点续传
android 断点续传如何实现的,Android 断点续传原理以及实现
weixin_35888603的博客
05-25 1017
Android 断点续传原理以及实现0. 前言在Android开发中，断点续传听起来挺容易，在下载一个文件时点击暂停任务暂停，点击开始会继续下载文件。但是真正实现起来知识点还是蛮多的，因此今天有时间实现了一下，并进行记录。1. 断点续传原理在本地下载过程中要使用数据库实时存储到底存储到文件的哪个位置了，这样点击开始继续传递时，才能通过HTTP的GET请求中的setRequestProperty...
断点续传
TTHHVV的博客
11-11 561
1.导入依赖 compile 'com.loopj.android:android-async-http:1.4.9' 2.导入权限 uses-permission android:name="android.permission.INTERNET">uses-permission> uses-permission android:name="android.permissio
android 细数断点续传的坑
坚持，努力
05-08 4683
android项目中，不可避免会下载一些第三方应用，或者自身更新的包，或者下载视频文件，那么都会考虑用到断线续传的方式。 那么，断电续传的方式大概有3种： 1.比如下载视频的时候，调用js的方法，把文件下载下来，然后用randomAccessFile合并成一个文件。 2.如xUtils的断点续传代码，具体自己看。 3.利用sqlite，配合上randomAccessFile
【Web】CTFSHOW 中期测评刷题记录(1)
uuzeray的博客
05-02 841
访问./cache/6a992d5529f459a44fee58c733255e86.php，命令执行拿flag。login.php是在./templates下的，而./flag.php与./templates均为web目录。注意到用./template/error.php中存在{{username}}，可以用其cache来写马。这时候重开下靶机再去读./templates/index.php，发现是给了提示的。访问./config/settings.php，命令执行拿到flag。
php利用阿里云短信SDK实现短信发送功能
最新发布
赛时科技
05-02 456
在阿里云控制台的AccessKey管理中，创建或查看AccessKey ID和AccessKey Secret，这是用于API调用的身份凭证。用户在前端接收到短信验证码后，需要在你的系统中进行验证。在实际部署之前，确保在测试环境中充分测试你的短信验证码登录功能。首先，你需要有一个阿里云账号，并在阿里云控制台中开通短信服务（Dysmsapi）。你可以使用Composer来安装阿里云短信服务的PHP SDK。在PHP中，你需要编写一个函数来调用阿里云短信服务API发送短信验证码。
android 断点续传 实现
03-28
Android断点续传是指在网络传输过程中，当传输中断或者失败时，能够从中断的位置继续传输而不需要重新开始。这样可以提高文件传输的效率和用户体验。 实现Android断点续传可以通过以下步骤： 1. 获取文件的总长度：在开始下载之前，首先需要获取文件的总长度，可以通过发送HTTP HEAD请求获取到Content-Length字段的值。 2. 创建一个临时文件：为了实现断点续传，需要将下载的文件保存到本地。可以创建一个临时文件来保存下载的数据。 3. 设置请求头：在发送HTTP请求时，需要设置Range请求头，指定下载的起始位置。如果之前已经下载了一部分文件，可以设置Range请求头为已下载的字节数到文件末尾。 4. 下载文件：使用HTTP请求库发送GET请求，将服务器返回的数据写入临时文件中。同时记录已下载的字节数。 5. 下载完成处理：当文件下载完成后，将临时文件重命名为最终的文件名。 6. 断点续传处理：如果下载过程中出现中断或者失败，可以记录已下载的字节数，并在下次下载时设置Range请求头为已下载的字节数到文件末尾。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值