断点分批加进度

最新推荐文章于 2024-01-24 11:02:23 发布
最新推荐文章于 2024-01-24 11:02:23 发布
阅读量266 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PlayAndroid/article/details/102905244
版权

小结

分批下载：向服务器请求数据回来时，分3次下载，(也可以多次)，首先来一次请求 获取总长以及设置步长
之后用RandomAccessFile随机流的seek的方法来保存长度，以便下一次读取继续下载；
断点续传及进度：调用RequestBody.create 的原方法，在原方法的上做修改，使用source去使用buffer读取并下载，在connectLength方法中记录上一次的上传的长度(需要从服务器获取)

具体代码

package com.example.test;

import android.Manifest;
import android.os.Bundle;
import android.os.Handler;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.SeekBar;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.internal.Util;
import okhttp3.logging.HttpLoggingInterceptor;
import okio.Buffer;
import okio.BufferedSink;
import okio.Okio;
import okio.Source;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "---";
    private Button textDownLoad;
    private Button textUpload;
    private SeekBar seekBar;
    private String download_url = "http://uvideo.spriteapp.cn/video/2019/0512/56488d0a-7465-11e9-b91b-1866daeb0df1_wpd.mp4";
    private String upload_url = "http://192.168.43.79/hfs/";
    private Handler handler = new Handler();
    private Button textUploads;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 100);
        initView();

    }

    private void initView() {
        textDownLoad = findViewById(R.id.text_downLoad);
        textUpload = findViewById(R.id.text_upload);
        seekBar = findViewById(R.id.seek_bar);
        textUploads = findViewById(R.id.text_uploads);

        textDownLoad.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                downLoad();
            }
        });

        textUpload.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                upLoad();
            }
        });

        textUploads.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                upLoads();
            }
        });
    }
    private File file_ups;
    private void upLoads() {
        file_ups = new File("/sdcard/ada.mp4");
        OkHttpClient client = new OkHttpClient.Builder().build();

//        RequestBody.create()
        RequestBody requestBody = new RequestBody() {
            @Override
            public @Nullable
            MediaType contentType() {
                return MediaType.parse("media/mp4");
            }

            //15000 这个长度是从服务器端获取的 但是目前hfs无法做到
            @Override
            public long contentLength() {
                return file_ups.length() - 15000;
            }

            @Override
            public void writeTo(BufferedSink sink) throws IOException {
                Source source = null;
                try {
                    source = Okio.source(file_ups);
                    Buffer buffer = new Buffer();
                    long len = 0;
                    while ((len = source.read(buffer, 1024)) != -1) {
                        sink.write(buffer, len);
                    }

                } finally {
                    Util.closeQuietly(source);
                }
            }
        };


        MultipartBody.Builder formDataPart = new MultipartBody.Builder()
                .addFormDataPart("file", "test2.mp4", requestBody);

        Request request = new Request.Builder()
                .url(upload_url)
                .post(formDataPart.build())
                .header("Connection","keep-alive")
                .header("Connect","*/*")
                .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 {

            }
        });
    }

    private File file_up;

    private void upLoad() {
        file_up = new File("/sdcard/ada.mp4");
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        Interceptor interceptor = new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request token = chain.request().newBuilder().header("token", "123321").build();

                String path = chain.request().url().encodedPath();
                String host = chain.request().url().host();
                String method = chain.request().method();
                Log.i(TAG, "地址: " + path);
                Log.i(TAG, "主机地址: " + host);
                Log.i(TAG, "请求方法: " + method);
                return chain.proceed(token);
            }
        };
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(interceptor)
                .addInterceptor(httpLoggingInterceptor)
                .build();

//        RequestBody requestBody = RequestBody.create(MediaType.parse("media/mp4"), "/sdcard/ada.mp4");
        RequestBody requestBody = new RequestBody() {
            @Override
            public @Nullable
            MediaType contentType() {
                return MediaType.parse("media/mp4");
            }

            @Override
            public long contentLength() {
                return file_up.length();
            }

            @Override
            public void writeTo(BufferedSink sink) throws IOException {
                Source source = null;
                try {
                    source = Okio.source(file_up);
                    Buffer buffer = new Buffer();
                    long length = file_up.length();
                    long len = 0;
                    long count = 0;
                    while ((len = source.read(buffer, 1024)) != -1) {
                        sink.write(buffer, len);
                        count += len;
                        final int values = (int) (count * 100 / length);
                        Log.i(TAG, "writeTo: " + values);
                        seekBar.setProgress(values);

                    }


                } finally {
                    Util.closeQuietly(source);
                }
            }
        };

        MultipartBody.Builder formDataPart = new MultipartBody.Builder().addFormDataPart("file", "tests.mp4", requestBody);
        formDataPart.setType(MultipartBody.FORM);
        Request request = new Request.Builder()
                .url(upload_url)
                .post(formDataPart.build())
                .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 {

            }
        });
    }

    private long number;
    private long max;
    private long count;

    private void downLoad() {
        OkHttpClient client = new OkHttpClient.Builder().build();

        Request request = new Request.Builder()
                .get()
                .url(download_url)
                .build();

        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                max = response.body().contentLength();
                number = max / 3;
                Log.i(TAG, "onResponse: " + max);
                startLoad();
            }
        });


    }

    private File file;

    private void startLoad() {
        OkHttpClient client = new OkHttpClient.Builder().build();
        file = new File("/sdcard/ada.mp4");
        Request request = new Request.Builder()
                .header("Range", "bytes=0-" + number)
                .url(download_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 {
                ResponseBody body = response.body();
                InputStream is = body.byteStream();
                byte[] b = new byte[1024];
                int len = 0;
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
                randomAccessFile.seek(0);
                while ((len = is.read(b)) != -1) {
                    count += len;
                    final int values = (int) (count * 100 / max);
                    randomAccessFile.write(b, 0, len);
                    Log.i(TAG, "Thread1: " + values);
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            seekBar.setProgress(values);
                        }
                    });
                }
            }
        });
        Request request1 = new Request.Builder()
                .header("Range", "bytes=" + number + "-" + number * 2)
                .url(download_url)
                .build();

        client.newCall(request1).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                ResponseBody body = response.body();
                InputStream is = body.byteStream();
                byte[] b = new byte[1024];
                int len = 0;
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
                randomAccessFile.seek(number);
                while ((len = is.read(b)) != -1) {
                    count += len;
                    final int values = (int) (count * 100 / max);
                    randomAccessFile.write(b, 0, len);
                    Log.i(TAG, "Thread2: " + values);
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            seekBar.setProgress(values);
                        }
                    });
                }
            }
        });
        Request request2 = new Request.Builder()
                .header("Range", "bytes=" + number * 2 + "-" + max)
                .url(download_url)
                .build();

        client.newCall(request2).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                ResponseBody body = response.body();
                InputStream is = body.byteStream();
                byte[] b = new byte[1024];
                int len = 0;
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
                randomAccessFile.seek(number * 2);
                while ((len = is.read(b)) != -1) {
                    count += len;
                    final int values = (int) (count * 100 / max);
                    randomAccessFile.write(b, 0, len);
                    Log.i(TAG, "Thread3: " + values);
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            seekBar.setProgress(values);
                        }
                    });
                }
            }
        });
    }
}
Pan_yu_ming
关注
C# http下载大文件，支持断点下载
努力学习中的博客
05-20 1419
C# http下载大文件，支持断点下载
kill应用以后，android断点续传的实现
小王子的博客
08-16 619
看了网上很多关于Android断点续传的文章，方法多样，但是涉及断网、断电的情况却很少。因为我在的公司做的是盒子游戏，通过一个Android系统的机顶盒，用来在Unity3D和服务器之间进行通。老板要求更新APP应用的时候，在wifi断开或者盒子突然断电，重新打开应用的时候，要求继续更新而不是重新下载。这个问题困恼了我几天，最后参考了http://blog.csdn.net/a1533588867
断点是什么，断点有哪几种类型？
热门推荐
ThinkStu的博客
06-30 9万+
断点是在特定点暂停程序执行的特殊标记，使用断点可以使你检查当前程序状态和行为。
使用websocket进行断点续传文件
奔波儿灞与霸波儿奔的博客
05-14 7673
使用websocket进行断点续传文件 上传要点 断点上传的目标是为了将大型文件分批分片上传，在服务端进行接收并组合，最终完成上传 代码 websocket接收文件 /** * websocket断点上传文件 * zhanghaichao */ @ServerEndpoint("/websocket/fileup") public class FileServer { ...
前端文件上传（文件上传，分片上传，断点续传）
STATICHIT静砸的博客
01-24 5239
如果需要重新上传该文件，则可以在下一次上传任务中，首先检查之前已上传的切片信息，如果存在已上传的切片，则可以直接跳过这些切片并进行后续的上传操作。具体实现方法可以根据上传任务的特点来确定，如将上传任务分为多个阶段，每个阶段上传一定数量的切片，如果某个阶段上传失败，则跳过该阶段并记录下失败的切片信息，待后续再进行重传。而通过分片上传，即使某个小块上传失败，只需要重新上传该小块，而不必重新上传整个文件。同时，如果某个小块上传失败，可以重试该小块，而不会影响其他小块的上传，从而提高上传的稳定性。
大附件分片上传、断点续传
good_boys的博客
08-03 337
相关实现： https://segmentfault.com/a/1190000021945539?utm_source=tag-newest https://mp.weixin.qq.com/s/f2Una_4u6xecEyrto47_Fg
下载器断点下载-方便游戏强更
weixin_34175509的博客
08-09 86
2019独角兽企业重金招聘Python工程师标准>>> ...
网络基本原理和加密
梦浮生清月夜
03-01 2386
数据加密1. base64编码加密一种简单的加密方式,本质是将任意的二进制数据编码成字符串,在网络上传输.//终端命令 base64编码 base64 xx.png -o abc.txt 编码文件 echo -n "Man" | base64 编码字符串 base64解码 base64 abc.txt -o xx.png -D 解码文件 echo -n "TWFu" |
vue 实现文件上传和下载和vue实现分片上传和断点续传
qq_36262295的博客
04-27 3300
vue中的文件上传主要分为两步：前台获取到文件和提交到后台 获取文件 前台获取文件，主要是采用input框来实现 <input type="file" ref="clearFile" @change="getFile($event)" multiple="multiplt" class="add-file-right-input" style="margin-left:70px;" accept=".docx,.doc,.pdf"> 通过file类型的input框实
Http断点续传原理及flex实现技术
12-05
通过这种方式，客户端可以在任何时候重新发起下载请求并恢复到上次的下载进度，从而实现了断点续传的功能。 #### 二、Flex实现的文件下载断点续传 接下来，我们将介绍如何使用AS3（ActionScript 3）、Flash Player...
webuploader MVC 切片上传-断点续传-秒传Demo
04-17
在大文件上传场景下，切片上传是一种优化策略，它将一个大文件分割成多个小块（或称为“切片”），然后分批上传。这种技术的优点在于可以提高上传效率，减少网络拥塞，并且在单个切片上传失败时，只需要重新上传失败...
c#异步多线程http文件分块断点续传下载工具
01-27
7. **进度更新与界面同步**：使用事件或回调函数更新UI上的下载进度，确保用户能够实时了解下载状态。 在实际开发中，还需要考虑其他因素，如文件的权限管理、多用户并发下载的冲突处理、网络条件变化时的动态调整...
Unity断点续传功能—商业项目使用的.zip
06-20
断点续传的关键在于记录当前下载进度。这通常通过保存文件的部分内容和已下载的字节数来实现。当下载再次启动时，系统会检查已存在的部分文件，并向服务器请求剩余部分。 三、Unity实现断点续传步骤 1. **检测已...
测表自动组装机_三维3D设计图纸.zip
09-29
测表自动组装机_三维3D设计图纸.zip
美萍民宿客栈收银管理系统标准版2021v1
09-29
美萍民宿客栈收银管理系统标准版2021v1官方正式版，要有加密狗才可以安装使用。
基于ThinkPHP6的ChatGPT接口接入与调用设计源码
最新发布
09-29
该项目是一款基于ThinkPHP6框架开发的ChatGPT接口接入与调用设计源码，包含51个文件，其中包括33个PHP源代码文件、4个HTML文件、4个Git忽略文件、2个文本文件、2个Markdown文件、1个htaccess文件、1个JSON文件、1个锁定文件和1个ICO文件。该系统实现了对ChatGPT接口的调用与集成，适用于需要集成智能聊天功能的Web应用开发。
基于C#的教师授课系统设计与实现.docx
09-29
基于C#的教师授课系统设计与实现.docx
基于asp.net的房产公司综合信息管理系统设计与实现.docx
09-29
基于asp.net的房产公司综合信息管理系统设计与实现.docx
Android多线程断点下载实现及进度显示
本资源详细介绍了如何在Android应用中实现实时进度显示的多线程断点下载功能。 首先，断点下载是指当下载过程中由于网络问题或其他原因中断后，可以从上次中断的地方继续下载，而不是重新开始。为了实现这一点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值