NewPipe/app/src/main/java/us/shandian/giga/get/DownloadRunnable.java

package us.shandian.giga.get;

import android.util.Log;

import java.io.BufferedInputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

import static org.schabi.newpipe.BuildConfig.DEBUG;

/**
 * Runnable to download blocks of a file until the file is completely downloaded,
 * an error occurs or the process is stopped.
 */
public class DownloadRunnable implements Runnable
{
	private static final String TAG = DownloadRunnable.class.getSimpleName();
	
	private final DownloadMission mMission;
	private final int mId;
	
	public DownloadRunnable(DownloadMission mission, int id) {
		if(mission == null) throw new NullPointerException("mission is null");
		mMission = mission;
		mId = id;
	}
	
	@Override
	public void run() {
		boolean retry = mMission.recovered;
		long position = mMission.getPosition(mId);
		
		if (DEBUG) {
			Log.d(TAG, mId + ":default pos " + position);
			Log.d(TAG, mId + ":recovered: " + mMission.recovered);
		}
		
		while (mMission.errCode == -1 && mMission.running && position < mMission.blocks) {
			
			if (Thread.currentThread().isInterrupted()) {
				mMission.pause();
				return;
			}
			
			if (DEBUG && retry) {
				Log.d(TAG, mId + ":retry is true. Resuming at " + position);
			}
			
			// Wait for an unblocked position
			while (!retry && position < mMission.blocks && mMission.isBlockPreserved(position)) {
				
				if (DEBUG) {
					Log.d(TAG, mId + ":position " + position + " preserved, passing");
				}
				
				position++;
			}
			
			retry = false;
			
			if (position >= mMission.blocks) {
				break;
			}
			
			if (DEBUG) {
				Log.d(TAG, mId + ":preserving position " + position);
			}
			
			mMission.preserveBlock(position);
			mMission.setPosition(mId, position);
			
			long start = position * DownloadManager.BLOCK_SIZE;
			long end = start + DownloadManager.BLOCK_SIZE - 1;
			
			if (end >= mMission.length) {
				end = mMission.length - 1;
			}
			
			HttpURLConnection conn = null;
			
			int total = 0;
			
			try {
				URL url = new URL(mMission.url);
				conn = (HttpURLConnection) url.openConnection();
				conn.setRequestProperty("Range", "bytes=" + start + "-" + end);
				
				if (DEBUG) {
					Log.d(TAG, mId + ":" + conn.getRequestProperty("Range"));
					Log.d(TAG, mId + ":Content-Length=" + conn.getContentLength() + " Code:" + conn.getResponseCode());
				}
				
				// A server may be ignoring the range request
				if (conn.getResponseCode() != 206) {
					mMission.errCode = DownloadMission.ERROR_SERVER_UNSUPPORTED;
					notifyError(DownloadMission.ERROR_SERVER_UNSUPPORTED);
					
					if (DEBUG) {
						Log.e(TAG, mId + ":Unsupported " + conn.getResponseCode());
					}
					
					break;
				}
				
				RandomAccessFile f = new RandomAccessFile(mMission.location + "/" + mMission.name, "rw");
				f.seek(start);
				BufferedInputStream ipt = new BufferedInputStream(conn.getInputStream());
				byte[] buf = new byte[512];
				
				while (start < end && mMission.running) {
					int len = ipt.read(buf, 0, 512);
					
					if (len == -1) {
						break;
					} else {
						start += len;
						total += len;
						f.write(buf, 0, len);
						notifyProgress(len);
					}
				}
				
				if (DEBUG && mMission.running) {
					Log.d(TAG, mId + ":position " + position + " finished, total length " + total);
				}
				
				f.close();
				ipt.close();
				
				// TODO We should save progress for each thread
			} catch (Exception e) {
				// TODO Retry count limit & notify error
				retry = true;
				
				notifyProgress(-total);
				
				if (DEBUG) {
					Log.d(TAG, mId + ":position " + position + " retrying", e);
				}
			}
		}
		
		if (DEBUG) {
			Log.d(TAG, "thread " + mId + " exited main loop");
		}
		
		if (mMission.errCode == -1 && mMission.running) {
			if (DEBUG) {
				Log.d(TAG, "no error has happened, notifying");
			}
			notifyFinished();
		}
		
		if (DEBUG && !mMission.running) {
			Log.d(TAG, "The mission has been paused. Passing.");
		}
	}
	
	private void notifyProgress(final long len) {
		synchronized (mMission) {
			mMission.notifyProgress(len);
		}
	}
	
	private void notifyError(final int err) {
		synchronized (mMission) {
			mMission.notifyError(err);
			mMission.pause();
		}
	}
	
	private void notifyFinished() {
		synchronized (mMission) {
			mMission.notifyFinished();
		}
	}
}