some changes

Author: nikita-yfh

app/src/main/java/ru/nikita/adb/BackedBlock.java

@@ -3,8 +3,8 @@
 import java.util.List;
 import java.util.ArrayList;
 import java.lang.Exception;
-import java.io.File;
-import java.io.FileInputStream;
+import java.io.RandomAccessFile;
+import java.io.IOException;
 import java.io.FileNotFoundException;
 import android.os.Bundle;
 import android.os.AsyncTask;
@@ -27,6 +27,7 @@
 import android.content.IntentFilter;
 import android.hardware.usb.UsbManager;
 import android.hardware.usb.UsbDevice;
+import android.util.Log;
 import ru.nikita.adb.FastbootVariablesListActivity;
 import ru.nikita.adb.PartitionListActivity;
 import ru.nikita.adb.FastbootDevice;
@@ -239,47 +240,99 @@ protected void onPreExecute() {
 		protected void onProgressUpdate(Integer ... values) {
 			pd.setProgress(values[0]);
 			pd.setMax(values[1]);
+			String message = getResources().getString(R.string.sending);
 			if(values[0] == values[1])
-				pd.setMessage(String.format("%s '%s' %d/%d...", getResources().getString(R.string.writing), partition, values[2], values[3]));
-			else
-				pd.setMessage(String.format("%s '%s' %d/%d (%d KB)...", getResources().getString(R.string.sending), partition, values[2], values[3], values[1] / 1024));
+				message = getResources().getString(R.string.writing);
+			pd.setMessage(String.format("%s '%s' %d/%d", message, partition, values[2], values[3]));
 		}
 		@Override
 		protected void onPostExecute(Exception result) {
 			pd.dismiss();
-			if(result != null)
+			if(result != null) {
 				showToast(result);
+				result.printStackTrace();
+			}
 		}
 
-		private void downloadData(byte[] data, int part, int maxParts) {
-			int length = data.length;
-			int offset = 0;
-			device.downloadCommand(length);
-			int n = 0;
-			while(offset < length) {
-				offset = device.writeData(data, offset);
-				if(n++ % 300 == 0) // reduce lags
-					publishProgress(offset, length, part, maxParts);
-			}
+		//private class DownloadStream extends FastbootDevice.OutputStream {
+		//	DownloadStream(int length, int part, int maxParts) {
+		//		this.part = part;
+		//		this.maxParts = maxParts;
+		//		this.bytes = 0;
+		//	}
+
+		//	@Override
+		//	public synchronized void write(byte[] buffer, int offset, int count) {
+		//		Log.d("ADB", Integer.toString(bytes));
+		//		while(offset < count) {
+		//			int bytesWritten = device.writeData(buffer, offset);
+		//			offset += bytesWritten;
+		//			bytes += bytesWritten;
+		//			//publishProgress(bytes, 0x8000000, part, maxParts);
+		//		}
+		//	}
+
+		//	@Override
+		//	public synchronized void write(int b) {
+		//		Log.d("ADB", Integer.toString(bytes));
+		//		device.writeByte(b);
+		//		bytes++;
+		//		//publishProgress(bytes, 0x80000000, part, maxParts);
+		//	}
+
+		//	private int length;
+		//	private int part;
+		//	private int maxParts;
+		//}
+
+		private void downloadData(SparseFile file, int part, int maxParts) throws IOException {
+			byte[] data = file.getBytes();
+			device.downloadCommand(file.countLen());
+
+			RandomAccessFile f = new RandomAccessFile(String.format("/sdcard/sparse%d.img", part), "rw");
+			f.write(data);
+			f.close();
+
+			FastbootDevice.OutputStream stream = device.new OutputStream();
+			for(int bytes = 0; bytes < data.length; bytes += stream.write(data, bytes));
+			stream.close();
+
 			device.checkOkay();
 			publishProgress(1, 1, part, maxParts);
 		}
 
+		private void downloadData(RandomAccessFile file) throws IOException {
+			device.downloadCommand(file.length());
+
+			FastbootDevice.OutputStream stream = device.new OutputStream();
+			for(int bytes = 0; bytes < file.length(); bytes += stream.write(file, (int) file.length(), bytes));
+			stream.close();
+
+			device.checkOkay();
+			publishProgress(1, 1, 1, 1);
+		}
+
 		@Override
 		protected Exception doInBackground(Void ... args) {
 			try {
-				File file = new File(filePath);
-				if (!file.exists() || !file.isFile())
-					throw new FileNotFoundException("File not found");
-				long fileLength = file.length();
-				long sparseLimit = device.getSparseLimit();
-
-				byte[] data = new byte[(int) file.length()];
-				FileInputStream stream = new FileInputStream(file);
-				stream.read(data);
-
-				downloadData(data, 1, 1);
-				device.flash(partition);
+				RandomAccessFile file = new RandomAccessFile(filePath, "r");
+				int fileLength = (int) file.length();
+				int sparseLimit = device.getSparseLimit();
+
+				if(fileLength <= sparseLimit) {
+					downloadData(file);
+					device.flash(partition);
+				} else {
+					SparseFile sparse = new SparseFile(file);
+					SparseFile[] files = sparse.resparse(sparseLimit);
+					device.erase(partition);
+					for(int i = 0; i < files.length; i++) {
+						Log.v("ADB", "Downloading");
+						downloadData(files[i], i + 1, files.length);
+						Log.v("ADB", "Flashing");
+						device.flash(partition);
+					}
+				}
 			} catch(Exception e) {
 				return e;
 			}
@@ -294,7 +347,6 @@ protected Exception doInBackground(Void ... args) {
 		private ProgressDialog pd;
 	}
 
-
 	public void flash(View view) {
 		if(getSelectedDevice().openConnection(this)) {
 			String filePath = ((EditText) findViewById(R.id.image_path)).getText().toString();

app/src/main/java/ru/nikita/adb/BackedBlockFile.java

@@ -4,6 +4,9 @@
 import java.util.Iterator;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.io.RandomAccessFile;
+import java.io.IOException;
+import java.nio.ByteBuffer;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ -15,6 +18,7 @@
 import android.hardware.usb.UsbInterface;
 import android.hardware.usb.UsbConstants;
 import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbRequest;
 import android.util.Log;
 import ru.nikita.adb.FastbootVariable;
 import ru.nikita.adb.FastbootException;
@@ -61,23 +65,32 @@ public boolean openConnection(Context context) {
 	}
 
 	private void rawCommand(String command) {
-		byte[] bytes = command.getBytes();
-		connection.bulkTransfer(out, bytes, bytes.length, 0);
+		UsbRequest request = new UsbRequest();
+		request.initialize(connection, out);
+		request.queue(ByteBuffer.allocate(command.length()).put(command.getBytes()), command.length());
+		connection.requestWait();
+		request.close();
 	}
 
 	private String readOnce() {
-		byte[] bytes = new byte[1024];
-		int length = connection.bulkTransfer(in, bytes, bytes.length, 0);
-		String response = new String(bytes, 0, length);
-		if(response.startsWith("FAIL"))
-			throw new FastbootException(response);
-		return response;
+		int bufferMaxLength = in.getMaxPacketSize();
+		ByteBuffer buffer = ByteBuffer.allocate(bufferMaxLength);
+		UsbRequest request = new UsbRequest();
+		request.initialize(connection, in);
+		request.queue(buffer, bufferMaxLength);
+		connection.requestWait();
+		request.close();
+
+		Log.v("ADB", String.format("Buffer position: %d, size: %d", buffer.position(), buffer.limit()));
+
+		String string = new String(buffer.array(), 0, buffer.position());
+		if(string.startsWith("FAIL"))
+			throw new FastbootException(string);
+		return string;
 	}
 
 	private String readOkay() {
-		byte[] bytes = new byte[1024];
-		int length = connection.bulkTransfer(in, bytes, bytes.length, 0);
-		String response = new String(bytes, 0, length);
+		String response = readOnce();
 		if(!response.startsWith("OKAY"))
 			throw new FastbootException(response);
 		return response.substring(4);
@@ -114,9 +127,9 @@ public String getVariable(String name) {
 		return readOkay();
 	}
 
-	public long getSparseLimit() {
+	public int getSparseLimit() {
 		String str = getVariable("max-download-size");
-		return Long.decode(str);
+		return Integer.decode(str);
 	}
 
 	public boolean hasVbmetaPartiton() {
@@ -141,25 +154,47 @@ public FastbootVariable[] getAllVariables() {
 		return list.toArray(new FastbootVariable[0]);
 	}
 
-	public void downloadCommand(int length) {
+	public void downloadCommand(long length) {
 		rawCommand(String.format("download:%08x", length));
 		String response = readOnce();
 		if(!response.startsWith("DATA") || Integer.parseInt(response.substring(4), 16) != length)
 			throw new FastbootException("Invalid response");
 	}
 
-	public int writeData(byte[] data, int offset) {
-		int size = Math.min(data.length - offset, out.getMaxPacketSize());
-		int bytesWritten = connection.bulkTransfer(out, Arrays.copyOfRange(data, offset, offset + size), size, 0);
-		offset += bytesWritten;
-		return offset;
-	}
-
 	public void flash(String partition) {
 		rawCommand("flash:" + partition);
 		readOnce();
 	}
 
+	public class OutputStream {
+		OutputStream() {
+			request = new UsbRequest();
+			request.initialize(connection, out);
+		}
+		public void close() {
+			request.close();
+		}
+		public int write(byte[] data) {
+			if(!request.queue(ByteBuffer.allocate(data.length).put(data), data.length))
+				throw new FastbootException("Writing error");
+			if(connection.requestWait() == null)
+				throw new FastbootException("Writing error");
+			return data.length;
+		}
+		public int write(byte[] array, int offset) throws IOException {
+			int size = Math.min((int) array.length - offset, out.getMaxPacketSize());
+			byte[] data = new byte[size];
+			return write(data);
+		}
+		public int write(RandomAccessFile file, int count, int offset) throws IOException {
+			int size = Math.min((int) file.length() - offset, out.getMaxPacketSize());
+			byte[] data = new byte[size];
+			file.read(data, 0, size);
+			return write(data);
+		}
+		private UsbRequest request;
+	}
+
 	private UsbManager manager;
 	private UsbDevice device;
 	private UsbInterface iface;