Service之断点续传（下载）

最新推荐文章于 2021-05-25 19:26:35 发布
最新推荐文章于 2021-05-25 19:26:35 发布
阅读量410 收藏
点赞数
分类专栏： android学习路

涉及知识点：

1.Service
2.intentStart.putExtra(“fileInfo”, fileInfo);//把实体类存入Intent中，fileInfo = (FileInfo) intent.getSerializableExtra(“fileInfo”);//从Intent中取出实体类
3.获得SD卡目录：Environment.getExternalStorageDirectory().getAbsolutePath()
4.发送消息给handler： mHandler.obtainMessage(MSG_INIT, fileInfo).sendToTarget();
5. conn.setRequestProperty(“Range”, “bytes=”+start+”-“+end);//读取这部分内容
6. raf.seek(start);//在读写的时候跳过设置的字节，比如seek(100),跳过100字节，从101开始读写

效果

这里写图片描述

MainActivity

package com.example.day0313;

import com.example.day0313.entity.FileInfo;
import com.example.day0313.service.DownloadService;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Filter;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener{

    private String TAG = "MainActivity";
    private TextView mTvFileName;
    private ProgressBar mPbDownload;
    private Button mBtStart;
    private Button mBtStop;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction(DownloadService.ACTION_UPDATE);
        registerReceiver(receiver, filter);

        initView();

    }

    BroadcastReceiver receiver = new BroadcastReceiver(){

        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(DownloadService.ACTION_UPDATE)) {
                int progress = intent.getIntExtra("finished", 0);
                mPbDownload.setProgress(progress);
            }
        }};

    @Override
    protected void onDestroy() {
        unregisterReceiver(receiver);
        super.onDestroy();
    }

    private void initView() {
        mTvFileName =  (TextView) findViewById(R.id.tv_name);
        mPbDownload =  (ProgressBar) findViewById(R.id.pb_download);
        mBtStart =  (Button) findViewById(R.id.bt_start);
        mBtStart.setOnClickListener(this);
        mBtStop =  (Button) findViewById(R.id.bt_stop);
        mBtStop.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        FileInfo fileInfo = new FileInfo(1, "http://www.imooc.com/mobile/mukewang.apk", "mukewang.apk", 0, 0);
        switch (v.getId()) {
        case R.id.bt_start:
            Intent intentStart = new Intent(this, DownloadService.class);
            intentStart.putExtra("fileInfo", fileInfo);
            intentStart.setAction(DownloadService.ACTION_START);
            startService(intentStart);
            break;

        case R.id.bt_stop:
            Intent intentStop = new Intent(this, DownloadService.class);
            intentStop.putExtra("fileInfo", fileInfo);
            intentStop.setAction(DownloadService.ACTION_STOP);
            startService(intentStop);
            break;
        }

    }


}

DownloadService

package com.example.day0313.service;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;


import com.example.day0313.entity.FileInfo;

import android.app.Service;
import android.content.Intent;
import android.os.Environment;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;

public class DownloadService extends Service{
    public static final String ACTION_START = "ACTION_START";
    public static final String ACTION_STOP = "ACTION_STOP";
    public static final String ACTION_UPDATE = "ACTION_UPDATE";
    public static final String TAG = "DownloadService";
    public static final int MSG_INIT = 1;
    public static final String DIR_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/AABCdownlaods/";
    private DownlaodTask mDownlaodTask = null;
    private Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case MSG_INIT:
                FileInfo fileInfo = (FileInfo) msg.obj;
                //下载
                mDownlaodTask = new DownlaodTask(DownloadService.this, fileInfo);
                mDownlaodTask.download();
                break;
            }
        };
    };

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        FileInfo fileInfo = null;
        if (intent.getAction().equals(ACTION_START)) {
            fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            new DownloadThread(fileInfo).start();
        } else if (intent.getAction().equals(ACTION_STOP)) {
            fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            if (mDownlaodTask != null) {
                mDownlaodTask.isPause = true;
            }
        }

        return super.onStartCommand(intent, flags, startId);
    }

    class DownloadThread extends Thread {
        private FileInfo fileInfo = null;

        public DownloadThread(FileInfo fileInfo) {
            this.fileInfo = fileInfo;
        }

        @SuppressWarnings("deprecation")
        @Override
        public void run() {
            HttpURLConnection conn = null;
             RandomAccessFile raf = null;
            try {
                //连接网络
                URL url = new URL(fileInfo.getUrl());
                conn = (HttpURLConnection) url.openConnection();
                conn.setConnectTimeout(3000);
                conn.setRequestMethod("GET");
                //访问是否成功
                if (conn.getResponseCode() != 200) {
                    Log.v(TAG, "访问失败");
                    return ;
                }
                //获得文件长度
                int length = -1;
                length = conn.getContentLength();
                //路径是否正确
                if (length <= 0) {
                    Log.v(TAG, "路径错误");
                    return ;
                }
                //创建文件写入
                //判断路径是否存在
                File dir = new File(DIR_PATH);
                Log.v(TAG, dir.exists()+"");
                if (!dir.exists()) {
                    dir.mkdir();//创建文件
                }
                //创建本地文件
                File file = new File(dir, fileInfo.getFileName());
                raf = new RandomAccessFile(file,"rwd");//r-可读,w-可写,d-可删
                raf.setLength(length);
                //发送长度给Handler,打印长度
                fileInfo.setLength(length);
                mHandler.obtainMessage(MSG_INIT, fileInfo).sendToTarget();

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                conn.disconnect();
            }
        }
    }


}

DownLoadTask

package com.example.day0313.service;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;

import com.example.day0313.db.ThreadDaoImpl;
import com.example.day0313.entity.FileInfo;
import com.example.day0313.entity.ThreadInfo;

import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class DownlaodTask {

    private String TAG = "DownlaodTask";
    private Context mContext;
    private FileInfo mFileInfo;
    private ThreadDaoImpl mDaoImpl;
    private int mFinished = 0;
    public boolean isPause = false;

    public DownlaodTask(Context context, FileInfo fileInfo) {
        this.mContext = context;
        this.mFileInfo = fileInfo;
        mDaoImpl = new ThreadDaoImpl(context);
    }

    public void download() {
        // 读取信息集合
        List<ThreadInfo> list = mDaoImpl.queryThreads(mFileInfo.getUrl());
        ThreadInfo threadInfo = null;
        if (list.size() == 0) {
            threadInfo = new ThreadInfo(0, mFileInfo.getUrl(), 0, mFileInfo.getLength(), 0);
        } else  {
            threadInfo = list.get(0);
        }

        //开始下载
        new DownloadThread(threadInfo).start();
    }

    public class DownloadThread extends Thread {

        private ThreadInfo mThreadInfo;


        public DownloadThread(ThreadInfo mThreadInfo) {
            this.mThreadInfo = mThreadInfo;
        }


        @Override
        public void run() {
            //先往数据库插入线程信息
            if (!mDaoImpl.isExist(mThreadInfo.getUrl(), mThreadInfo.getId())) {
                mDaoImpl.insertThread(mThreadInfo);
            }
            HttpURLConnection conn = null;
            RandomAccessFile raf = null;
            InputStream input = null;
            try {
                URL url = new URL(mThreadInfo.getUrl());
                conn = (HttpURLConnection) url.openConnection();
                conn.setConnectTimeout(3000);
                conn.setRequestMethod("GET");
                //设置下载的位置
                int start = mThreadInfo.getStart()+mThreadInfo.getFinished();
                int end = mThreadInfo.getEnd();
                conn.setRequestProperty("Range", "bytes="+start+"-"+end);
                //设置文件写入的位置
                File file = new File(DownloadService.DIR_PATH, mFileInfo.getFileName());
                raf = new RandomAccessFile(file, "rwd");
                raf.seek(start);//在读写的时候跳过设置的字节，比如seek(100),跳过100字节，从101开始读写
                Intent intent = new Intent(DownloadService.ACTION_UPDATE);
                mFinished += mThreadInfo.getFinished();
                //开始下载
                if (conn.getResponseCode() == 206) {
                    //读取数据
                    input = conn.getInputStream();
                    byte[] buffer = new byte[1024 * 4];
                    int len = -1;
                    while ((len = input.read(buffer)) != -1) {
                        //写入文件
                        raf.write(buffer,0,len);
                        mFinished += len;
                        mThreadInfo.setFinished(mFinished);
                        //把下载进度发送广播给activty
                        intent.putExtra("finished", mFinished * 100 / mFileInfo.getLength());
                        mContext.sendBroadcast(intent);
                        //在下载暂停时,保持进度到数据库
                        if (isPause) {
                            mDaoImpl.updateThread(mThreadInfo.getUrl(), mThreadInfo.getId(), mThreadInfo.getFinished());
                            return ; 
                        }
                    }

                    //删除线程信息
                    mDaoImpl.deleteThread(mThreadInfo.getUrl(), mThreadInfo.getId());
                }


            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    input.close();
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                conn.disconnect();
            }

        }
    }




}

DBHelper

package com.example.day0313.db;

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

public class DBHelper extends SQLiteOpenHelper {
    private static final String DB_NAME = "download.db";
    private static final int VERSION = 1;
    private static final String SQL_CREATE = "create table thread_info (_id integer primary key autoincrement, " +
            "thread_id integer, url text, start integer, end integer, finished integer)";
    private static final String SQL_DROP = "drop table if exists thread_info";


    public DBHelper(Context context) {
        super(context, DB_NAME, null, VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE);

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL(SQL_DROP);
        db.execSQL(SQL_CREATE);
    }

}

ThreadDao（接口）

package com.example.day0313.db;

import java.util.List;

import com.example.day0313.entity.ThreadInfo;

/**
 *  数据访问接口
 */
public interface ThreadDao {

    /**
     *  插入线程信息
     * @param threadInfo
     */
    public void insertThread(ThreadInfo threadInfo);

    /**
     * 删除线性信息
     * @param url
     * @param thread_id
     */
    public void deleteThread(String url, int thread_id);

    /**
     * 更新线程下载的进度
     * @param url
     * @param thread_id
     * @param finished
     */
    public void updateThread(String url, int thread_id, int finished);

    /**
     * 查询文件的线程信息
     * @param url
     * @return
     */
    public List<ThreadInfo> queryThreads(String url);

    /**
     * 判断这个线程是否在数据库中存在
     * @param url
     * @param thread_id
     * @return
     */
    public boolean isExist(String url, int thread_id);



}

ThreadDaoImpl（实现）

package com.example.day0313.db;

import java.util.ArrayList;
import java.util.List;

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

import com.example.day0313.entity.ThreadInfo;

public class ThreadDaoImpl implements ThreadDao{

    private DBHelper dbHelper = null;

    public ThreadDaoImpl(Context context) {
        dbHelper = new DBHelper(context);
    }


    @Override
    public void insertThread(ThreadInfo threadInfo) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        db.execSQL("insert into thread_info (thread_id, url, start, end, finished) values (?,?,?,?,?)",
                new Object[]{threadInfo.getId(), threadInfo.getUrl(), threadInfo.getStart(), threadInfo.getEnd(), threadInfo.getFinished()});
        db.close();
    }

    @Override
    public void deleteThread(String url, int thread_id) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        db.execSQL("delete from thread_info where url = ? and thread_id = ?",
                new Object[]{url, thread_id});
        db.close();
    }

    @Override
    public void updateThread(String url, int thread_id, int finished) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        db.execSQL("update thread_info set finished = ? where url = ? and thread_id = ?",
                new Object[]{finished, url, thread_id});
        db.close();
    }

    @Override
    public List<ThreadInfo> queryThreads(String url) {
        List<ThreadInfo> list = new ArrayList<ThreadInfo>();
        ThreadInfo threadInfo = null;
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        Cursor c = db.rawQuery("select * from thread_info where url = ?",
                new String[]{url});
        while (c.moveToNext()) {
            threadInfo = new ThreadInfo();
            threadInfo.setId(c.getInt(c.getColumnIndex("thread_id")));
            threadInfo.setUrl(c.getString(c.getColumnIndex("url")));
            threadInfo.setStart(c.getInt(c.getColumnIndex("start")));
            threadInfo.setEnd(c.getInt(c.getColumnIndex("end")));
            threadInfo.setFinished(c.getInt(c.getColumnIndex("finished")));
            list.add(threadInfo);
        }
        c.close();
        db.close();
        return list;
    }

    @Override
    public boolean isExist(String url, int thread_id) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        Cursor c = db.rawQuery("select * from thread_info where url = ? and thread_id = ?",
                new String[]{url, thread_id+""});
        boolean exists = c.moveToNext();
        c.close();
        db.close();
        return exists;
    }

}

FileInfo（实体类）

//
    private int id;
    private String url;
    private String fileName;
    private int length;
    private int finished;
//

ThreadInfo（实体类）

//
    private int id;
    private String url;
    private int start;
    private int end;
    private int finished;
//

权限

 <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

转载于：http://www.imooc.com/learn/363

u010542146
关注
专栏目录
用Service实现断点下载
weixin_34416649的博客
01-05 81
 整体的思路： 在下载文件时，将进度写入数据库，同一时候通知该ContentProvider的观察者更新页面，这个通知过程不要太频繁。我设置了10次，否则页面会灰常卡。 假设异常中断（网络中断或程序被kill）也没有关系。由于数据库中有记录，仅仅要从该文件的断点位置继续下载就能够了。关键在于一切以数据库为准 就能够了。 同一时候要注意的是： 1、自始至终处理的都是同...
Android断点调试Service
璐璐的专栏
05-27 5387
问题：以调试 模式启动Android 项目时，在service 中设置断点，调试器不会停止下来。 解决办法： 1.   Androidmanifest.xml配置文件，将service 配置后面的 android:process=":remote" 删除就可以了。 2.   使用Log，打印信息。 3.   等待添加调试器，添加了这条语句之后，可以在这个方法的任何地方添加断点。 在需要调
Service的使用：断点下载
lyh.
07-20 392
本文将使用到Service、OkHttp、AsyncTask、Notification、运行时权限申请。首先，将OkHttp的依赖库添加好。compile 'com.squareup.okhttp3:okhttp:3.8.1'接下来，定义一个回调接口，用于对下载过程中的各种状态进行监听和回调。新建一个DownloadListener接口，如下：public interface DownloadLis
WebService 大文件断点续传
weixin_30399155的博客
04-01 105
/// <summary> /// 服务端: /// </summary> /// <param name="FileName">更新文件包名</param> /// <param name="Offset">偏移</param&gt...
Android-Service系列之断点续传下载
04-29
本篇将深入探讨如何利用Service实现一个重要的功能：断点续传下载。断点续传下载允许用户在下载文件时中断进程，然后在之后的任意时间继续未完成的下载，而不必从头开始。 首先，理解Service的基本概念至关重要。...
RxJava+Retrofit+OkHttp实现多文件下载之断点续传
01-20
【RxJava+Retrofit+OkHttp实现多文件下载之断点续传】 在移动应用开发中，断点续传是一项非常关键的技术，特别是在文件下载场景中。它允许用户中断下载后，从上次中断的地方继续下载，提高了用户体验。RxJava、...
如何通过Web_Service_实现断点续传或下载文件.doc
12-22
本文将深入探讨如何利用Web Service实现文件的断点续传和下载功能，这对于大型文件传输尤其重要，因为它提高了效率并减少了网络资源的浪费。 ### 1. Web Service和断点续传 **1.1. Web Service** Web Service是一...
oss下载（断点续传，后台显示进度）源代码.rar
03-10
本"oss下载（断点续传，后台显示进度）源代码.rar"压缩包包含了一个实现阿里云OSS断点续传下载并带有进度条展示的示例代码。通过分析和学习这个代码，我们可以掌握以下几个关键知识点： 1. **阿里云OSS SDK**：首先...
通过idea断点分析service执行流程
yinbucheng的博客
04-18 1452
首先我们看下执行service执行delete(方法上面有@Transaction注解)操作调用栈delete:MyTestServiceImpl invoke0:NativeMethodAccessorImpl invoke:NativeMethodAccessorImpl invoke:Method invokeJoinpointUsingReflection:AopUtils invokeJ...
视频库之断点续传
折翼只为爱
07-30 475
        近日公司有个项目要做一个视频库，故开始阶段性研究。首先先要研究断点续传。         第一步：打算提高上传视频的时间，上传的时间分成两部分，读流和写入GFS。想做一个实验来验证到底时间花费在了哪里，故在程序中加入了打印语句。如下：        @Override protected void doPost(HttpServletRequest request,...
Android怎么在Service中打断点
qq_24229973的博客
06-25 2500
只需要在Service中的oncreat中添加下面这句话，然后启动的时候直接启动debug断点模式即可@Override public void onCreate() { android.os.Debug.waitForDebugger();
eclipse调试Android的service的时候断点没用
FENGFENG444333的专栏
09-11 907
在项目的配置文件AndroidManifest.xml中的service
Android如何调试一个Service？
TeekTon的专栏
11-29 6341
1、概述最近在看一个新的项目，由于其中在一个单独的进程中启动了一个Service。我想要调试Service中的代码，打了断点，但是在服务启动后并没有停在断点上。于是查询资料得到调试Service的方法如下。2、如何调试Service（1）我们需要用到android.os.Debug.waitForDebugger();在Service的onCreat中加入上面的代码。然后就可以在之后的代码中加入断点
android 断点续传如何实现的,Android 断点续传原理以及实现
weixin_35888603的博客
05-25 1052
Android 断点续传原理以及实现0. 前言在Android开发中，断点续传听起来挺容易，在下载一个文件时点击暂停任务暂停，点击开始会继续下载文件。但是真正实现起来知识点还是蛮多的，因此今天有时间实现了一下，并进行记录。1. 断点续传原理在本地下载过程中要使用数据库实时存储到底存储到文件的哪个位置了，这样点击开始继续传递时，才能通过HTTP的GET请求中的setRequestProperty...
Android用Service实现断点下载功能。
编码行者的博客
04-03 669
1、DownloadListener 下载接口 public interface DownloadListener { void onProgress(int progress); void onSuccess(); void onFailed(); void onPaused(); void onCanceled(); } 2、新建Dow...
DownloadManager使用详解
Android技术之家
08-01 3904
DownloadManger是android 2.3（api level 9）开始 提供的用于优化处理长时间的下载操作。DownloadManager 处理Http/Ht...
Android Service启动（一） startService()启动过程以及原理解析
生死看淡_不服就干的博客
01-06 5993
Service分为两种工作状态，启动状态和绑定状态,通过调用startService()可进入启动状态，通过bindService()可进入绑定状态，本篇文章主要讲解startService()启动Service的过程。（额，android的版本还是26） 我们平时通过startService()启动一个Service的时候，最终都是调用的ContextWrapper的...
使用RxJava+Retrofit+OkHttp实现断点续传下载
"本文主要介绍了如何使用RxJava、Retrofit和OkHttp库在Android应用中实现多文件的断点续传下载。通过这种方式，开发者可以构建一个灵活且安全的下载框架。文中首先强调了断点续传技术在移动开发中的重要性，并展示了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值