Android 实现断点续传

来源：互联网发布：淘宝客关键词选择编辑：程序博客网时间：2024/06/05 04:37

来自：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-Length59107
Content-Type text/html;charset=UTF-8
Date Fri, 03Jan 201402:40:27GMT
Etag"1946829081"
Expires Fri, 03Jan 201402:40:27GMT
LFY cq01.13
Last-Modified Fri, 03Jan 201402:40:00GMT
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
packagecom.johnny.testdownloadbreakpoint;
 
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.io.RandomAccessFile;
importjava.net.HttpURLConnection;
importjava.net.MalformedURLException;
importjava.net.URL;
importjava.net.URLConnection;
 
importandroid.app.AlertDialog;
importandroid.app.AlertDialog.Builder;
importandroid.app.ProgressDialog;
importandroid.content.Context;
importandroid.content.DialogInterface;
importandroid.content.DialogInterface.OnCancelListener;
importandroid.content.DialogInterface.OnClickListener;
importandroid.os.AsyncTask;
importandroid.util.Log;
 
publicclass DownLoaderTask extendsAsyncTask<void, integer,=""long=""> {
    privatefinal String TAG = "DownLoaderTask";
    privateURL mUrl;
    privateFile mFile;
    privateProgressDialog mDialog;
    privateint mProgress = 0;
    privateProgressReportingOutputStream mOutputStream;
    privateContext mContext;
    publicDownLoaderTask(String url,String out,Context context){
        super();
        if(context!=null){
            mDialog = newProgressDialog(context);
            mContext = context;
        }
        else{
            mDialog = null;
        }
         
        try{
            mUrl = newURL(url);
            String fileName = newFile(mUrl.getFile()).getName();
            mFile = newFile(out, fileName);
            Log.d(TAG,"out="+out+", name="+fileName+",mUrl.getFile()="+mUrl.getFile());
        }catch(MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         
    }
     
    @Override
    protectedvoid 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(newOnCancelListener() {
                 
                @Override
                publicvoid onCancel(DialogInterface dialog) {
                    // TODO Auto-generated method stub
                    cancel(true);
                }
            });
            mDialog.show();
        }
    }
 
    @Override
    protectedLong doInBackground(Void... params) {
        // TODO Auto-generated method stub
        if(!checkURL()){
            Log.e(TAG,"url can not access.....");
            return0l;
        }
        returndownload();
    }
 
    @Override
    protectedvoid onProgressUpdate(Integer... values) {
        // TODO Auto-generated method stub
        //super.onProgressUpdate(values);
        if(mDialog==null)
            return;
        if(values.length>1){
            intcontentLength = values[1];
            if(contentLength==-1){
                mDialog.setIndeterminate(true);
            }
            else{
                mDialog.setMax(contentLength);
            }
        }
        else{
            mDialog.setProgress(values[0].intValue());
        }
    }
 
    @Override
    protectedvoid onPostExecute(Long result) {
        // TODO Auto-generated method stub
        //super.onPostExecute(result);
        if(mDialog!=null&&mDialog.isShowing()){
            mDialog.dismiss();
        }
        if(isCancelled())
            return;
    }
 
    privatelong download(){
        URLConnection connection = null;
        intbytesCopied = 0;
        try{
            connection = mUrl.openConnection();
            intlength = connection.getContentLength();
            if(mFile.exists()&&length == mFile.length()){
                Log.d(TAG,"file "+mFile.getName()+" already exits!!");
                return0l;
            }
            elseif(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);
                }
            }
            elseif(!mFile.exists()){
                mOutputStream = newProgressReportingOutputStream(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();
        }
        returnbytesCopied;
    }
    privateint copy(InputStream input, OutputStream output){
        byte[] buffer = newbyte[1024*8];
        BufferedInputStream in = newBufferedInputStream(input, 1024*8);
        BufferedOutputStream out  = newBufferedOutputStream(output, 1024*8);
        intcount =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();
            }
        }
        returncount;
    }
    privateint copyFromBreakPoint(InputStream input, File output){
        byte[] buffer = newbyte[1024*8];
        intcount =0,n=0;
        try{
            RandomAccessFile fos = newRandomAccessFile(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();
        }
         
        return0;
    }
    privateboolean checkURL(){
        booleanret = false;
        try{
            HttpURLConnection conn = (HttpURLConnection) mUrl.openConnection();
            if(conn.getResponseCode()==200)
                ret=true;
        }catch(IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        returnret;
    }
    privatefinal class ProgressReportingOutputStream extendsFileOutputStream{
 
        publicProgressReportingOutputStream(File file)
                throwsFileNotFoundException {
            super(file);
            // TODO Auto-generated constructor stub
        }
 
        @Override
        publicvoid write(byte[] buffer, intbyteOffset, intbyteCount)
                throwsIOException {
            // 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
packagecom.johnny.testdownloadbreakpoint;
 
importandroid.os.Bundle;
importandroid.app.Activity;
importandroid.view.Menu;
 
publicclass MainActivity extendsActivity {
 
    @Override
    protectedvoid onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        doDownLoadWork();
    }
 
    @Override
    publicboolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        returntrue;
    }
    privatevoid doDownLoadWork(){
        DownLoaderTask task = newDownLoaderTask("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();
    }
 
}

0 0