conversations-classic/src/main/java/eu/siacs/conversations/http/HttpDownloadConnection.java

355 lines
11 KiB
Java
Raw Normal View History

2014-10-13 23:06:45 +00:00
package eu.siacs.conversations.http;
import android.os.PowerManager;
import android.util.Log;
2014-10-13 23:06:45 +00:00
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
2014-10-13 23:06:45 +00:00
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.CancellationException;
2014-10-13 23:06:45 +00:00
import javax.net.ssl.HttpsURLConnection;
2014-10-19 21:42:53 +00:00
import javax.net.ssl.SSLHandshakeException;
2014-10-13 23:06:45 +00:00
import eu.siacs.conversations.Config;
import eu.siacs.conversations.R;
2014-10-14 10:02:48 +00:00
import eu.siacs.conversations.entities.DownloadableFile;
2014-10-13 23:06:45 +00:00
import eu.siacs.conversations.entities.Message;
2015-07-20 12:26:29 +00:00
import eu.siacs.conversations.entities.Transferable;
import eu.siacs.conversations.entities.TransferablePlaceholder;
import eu.siacs.conversations.persistance.FileBackend;
import eu.siacs.conversations.services.AbstractConnectionManager;
2014-10-13 23:06:45 +00:00
import eu.siacs.conversations.services.XmppConnectionService;
import eu.siacs.conversations.utils.CryptoHelper;
2014-10-13 23:06:45 +00:00
public class HttpDownloadConnection implements Transferable {
2014-10-13 23:06:45 +00:00
private HttpConnectionManager mHttpConnectionManager;
private XmppConnectionService mXmppConnectionService;
private URL mUrl;
private Message message;
private DownloadableFile file;
2015-07-10 13:11:03 +00:00
private int mStatus = Transferable.STATUS_UNKNOWN;
private boolean acceptedAutomatically = false;
2014-11-13 20:04:05 +00:00
private int mProgress = 0;
2015-11-28 19:11:38 +00:00
private boolean mUseTor = false;
private boolean canceled = false;
2014-10-13 23:06:45 +00:00
public HttpDownloadConnection(HttpConnectionManager manager) {
2014-10-13 23:06:45 +00:00
this.mHttpConnectionManager = manager;
this.mXmppConnectionService = manager.getXmppConnectionService();
2015-11-28 19:11:38 +00:00
this.mUseTor = mXmppConnectionService.useTorToConnect();
2014-10-13 23:06:45 +00:00
}
@Override
public boolean start() {
if (mXmppConnectionService.hasInternetConnection()) {
2014-10-19 21:42:53 +00:00
if (this.mStatus == STATUS_OFFER_CHECK_FILESIZE) {
checkFileSize(true);
} else {
new Thread(new FileDownloader(true)).start();
2014-10-19 21:42:53 +00:00
}
return true;
} else {
return false;
}
2014-10-13 23:06:45 +00:00
}
public void init(Message message) {
2015-07-10 13:11:03 +00:00
init(message, false);
}
public void init(Message message, boolean interactive) {
2014-10-13 23:06:45 +00:00
this.message = message;
2015-07-10 13:11:03 +00:00
this.message.setTransferable(this);
2014-10-13 23:06:45 +00:00
try {
if (message.hasFileOnRemoteHost()) {
mUrl = message.getFileParams().url;
} else {
mUrl = new URL(message.getBody());
}
2015-01-11 14:19:36 +00:00
String[] parts = mUrl.getPath().toLowerCase().split("\\.");
String lastPart = parts.length >= 1 ? parts[parts.length - 1] : null;
String secondToLast = parts.length >= 2 ? parts[parts.length -2] : null;
if ("pgp".equals(lastPart) || "gpg".equals(lastPart)) {
this.message.setEncryption(Message.ENCRYPTION_PGP);
} else if (message.getEncryption() != Message.ENCRYPTION_OTR
&& message.getEncryption() != Message.ENCRYPTION_AXOLOTL) {
this.message.setEncryption(Message.ENCRYPTION_NONE);
}
2015-01-11 14:19:36 +00:00
String extension;
2016-03-04 10:24:53 +00:00
if (VALID_CRYPTO_EXTENSIONS.contains(lastPart)) {
2015-01-11 14:19:36 +00:00
extension = secondToLast;
} else {
extension = lastPart;
}
message.setRelativeFilePath(message.getUuid() + "." + extension);
2015-01-11 14:19:36 +00:00
this.file = mXmppConnectionService.getFileBackend().getFile(message, false);
String reference = mUrl.getRef();
if (reference != null && reference.length() == 96) {
this.file.setKeyAndIv(CryptoHelper.hexToBytes(reference));
}
if ((this.message.getEncryption() == Message.ENCRYPTION_OTR
|| this.message.getEncryption() == Message.ENCRYPTION_AXOLOTL)
&& this.file.getKey() == null) {
this.message.setEncryption(Message.ENCRYPTION_NONE);
}
2015-07-17 21:58:33 +00:00
checkFileSize(interactive);
2014-10-13 23:06:45 +00:00
} catch (MalformedURLException e) {
this.cancel();
}
}
2014-10-19 21:42:53 +00:00
private void checkFileSize(boolean interactive) {
new Thread(new FileSizeChecker(interactive)).start();
2014-10-13 23:06:45 +00:00
}
@Override
2014-10-13 23:06:45 +00:00
public void cancel() {
this.canceled = true;
mHttpConnectionManager.finishConnection(this);
if (message.isFileOrImage()) {
message.setTransferable(new TransferablePlaceholder(Transferable.STATUS_DELETED));
} else {
message.setTransferable(null);
}
mXmppConnectionService.updateConversationUi();
}
private void finish() {
mXmppConnectionService.getFileBackend().updateMediaScanner(file);
2015-07-10 13:11:03 +00:00
message.setTransferable(null);
mHttpConnectionManager.finishConnection(this);
boolean notify = acceptedAutomatically && !message.isRead();
if (message.getEncryption() == Message.ENCRYPTION_PGP) {
notify = message.getConversation().getAccount().getPgpDecryptionService().decrypt(message, notify);
}
mXmppConnectionService.updateConversationUi();
if (notify) {
mXmppConnectionService.getNotificationService().push(message);
}
2014-10-13 23:06:45 +00:00
}
private void changeStatus(int status) {
this.mStatus = status;
mXmppConnectionService.updateConversationUi();
}
private class WriteException extends IOException {
}
private void showToastForException(Exception e) {
if (e instanceof java.net.UnknownHostException) {
mXmppConnectionService.showErrorToastInUi(R.string.download_failed_server_not_found);
} else if (e instanceof java.net.ConnectException) {
mXmppConnectionService.showErrorToastInUi(R.string.download_failed_could_not_connect);
} else if (e instanceof WriteException) {
mXmppConnectionService.showErrorToastInUi(R.string.download_failed_could_not_write_file);
} else if (!(e instanceof CancellationException)) {
mXmppConnectionService.showErrorToastInUi(R.string.download_failed_file_not_found);
}
}
2014-10-13 23:06:45 +00:00
private class FileSizeChecker implements Runnable {
2014-10-19 21:42:53 +00:00
private boolean interactive = false;
public FileSizeChecker(boolean interactive) {
this.interactive = interactive;
}
2014-10-13 23:06:45 +00:00
@Override
public void run() {
long size;
2014-10-13 23:06:45 +00:00
try {
size = retrieveFileSize();
} catch (Exception e) {
2014-10-19 21:42:53 +00:00
changeStatus(STATUS_OFFER_CHECK_FILESIZE);
Log.d(Config.LOGTAG, "io exception in http file size checker: " + e.getMessage());
if (interactive) {
showToastForException(e);
} else {
HttpDownloadConnection.this.acceptedAutomatically = false;
HttpDownloadConnection.this.mXmppConnectionService.getNotificationService().push(message);
}
2014-10-13 23:06:45 +00:00
cancel();
return;
}
file.setExpectedSize(size);
if (mHttpConnectionManager.hasStoragePermission() && size <= mHttpConnectionManager.getAutoAcceptFileSize()) {
HttpDownloadConnection.this.acceptedAutomatically = true;
new Thread(new FileDownloader(interactive)).start();
} else {
changeStatus(STATUS_OFFER);
HttpDownloadConnection.this.acceptedAutomatically = false;
HttpDownloadConnection.this.mXmppConnectionService.getNotificationService().push(message);
2014-10-13 23:06:45 +00:00
}
}
private long retrieveFileSize() throws IOException {
try {
Log.d(Config.LOGTAG, "retrieve file size. interactive:" + String.valueOf(interactive));
changeStatus(STATUS_CHECKING);
2015-11-28 19:11:38 +00:00
HttpURLConnection connection;
if (mUseTor) {
connection = (HttpURLConnection) mUrl.openConnection(mHttpConnectionManager.getProxy());
} else {
connection = (HttpURLConnection) mUrl.openConnection();
}
connection.setRequestMethod("HEAD");
2015-11-28 19:11:38 +00:00
Log.d(Config.LOGTAG,"url: "+connection.getURL().toString());
Log.d(Config.LOGTAG,"connection: "+connection.toString());
connection.setRequestProperty("User-Agent", mXmppConnectionService.getIqGenerator().getIdentityName());
if (connection instanceof HttpsURLConnection) {
mHttpConnectionManager.setupTrustManager((HttpsURLConnection) connection, interactive);
}
connection.connect();
String contentLength = connection.getHeaderField("Content-Length");
connection.disconnect();
if (contentLength == null) {
throw new IOException("no content-length found in HEAD response");
}
return Long.parseLong(contentLength, 10);
} catch (IOException e) {
throw e;
} catch (NumberFormatException e) {
throw new IOException();
}
2014-10-13 23:06:45 +00:00
}
}
2014-10-13 23:06:45 +00:00
private class FileDownloader implements Runnable {
private boolean interactive = false;
private OutputStream os;
public FileDownloader(boolean interactive) {
this.interactive = interactive;
}
2014-10-13 23:06:45 +00:00
@Override
public void run() {
try {
changeStatus(STATUS_DOWNLOADING);
2014-10-13 23:06:45 +00:00
download();
2014-10-14 16:16:03 +00:00
updateImageBounds();
finish();
} catch (SSLHandshakeException e) {
changeStatus(STATUS_OFFER);
} catch (Exception e) {
if (interactive) {
showToastForException(e);
} else {
HttpDownloadConnection.this.acceptedAutomatically = false;
HttpDownloadConnection.this.mXmppConnectionService.getNotificationService().push(message);
}
2014-10-13 23:06:45 +00:00
cancel();
}
}
private void download() throws Exception {
InputStream is = null;
PowerManager.WakeLock wakeLock = mHttpConnectionManager.createWakeLock("http_download_"+message.getUuid());
try {
wakeLock.acquire();
2015-11-28 19:11:38 +00:00
HttpURLConnection connection;
if (mUseTor) {
connection = (HttpURLConnection) mUrl.openConnection(mHttpConnectionManager.getProxy());
} else {
connection = (HttpURLConnection) mUrl.openConnection();
}
if (connection instanceof HttpsURLConnection) {
mHttpConnectionManager.setupTrustManager((HttpsURLConnection) connection, interactive);
}
connection.setRequestProperty("User-Agent",mXmppConnectionService.getIqGenerator().getIdentityName());
final boolean tryResume = file.exists() && file.getKey() == null;
if (tryResume) {
Log.d(Config.LOGTAG,"http download trying resume");
long size = file.getSize();
connection.setRequestProperty("Range", "bytes="+size+"-");
}
connection.connect();
is = new BufferedInputStream(connection.getInputStream());
boolean serverResumed = "bytes".equals(connection.getHeaderField("Accept-Ranges"));
long transmitted = 0;
long expected = file.getExpectedSize();
if (tryResume && serverResumed) {
Log.d(Config.LOGTAG,"server resumed");
transmitted = file.getSize();
updateProgress((int) ((((double) transmitted) / expected) * 100));
os = AbstractConnectionManager.createAppendedOutputStream(file);
} else {
file.getParentFile().mkdirs();
file.createNewFile();
os = AbstractConnectionManager.createOutputStream(file, true);
}
int count;
byte[] buffer = new byte[1024];
while ((count = is.read(buffer)) != -1) {
transmitted += count;
try {
os.write(buffer, 0, count);
} catch (IOException e) {
throw new WriteException();
}
updateProgress((int) ((((double) transmitted) / expected) * 100));
if (canceled) {
throw new CancellationException();
}
}
try {
os.flush();
} catch (IOException e) {
throw new WriteException();
}
} catch (CancellationException | IOException e) {
throw e;
} finally {
FileBackend.close(os);
FileBackend.close(is);
wakeLock.release();
2014-10-13 23:06:45 +00:00
}
2014-10-14 16:16:03 +00:00
}
2014-10-14 16:16:03 +00:00
private void updateImageBounds() {
message.setType(Message.TYPE_FILE);
mXmppConnectionService.getFileBackend().updateFileParams(message, mUrl);
mXmppConnectionService.updateMessage(message);
}
}
public void updateProgress(int i) {
this.mProgress = i;
mXmppConnectionService.updateConversationUi();
}
@Override
public int getStatus() {
return this.mStatus;
}
@Override
public long getFileSize() {
if (this.file != null) {
return this.file.getExpectedSize();
} else {
return 0;
2014-10-13 23:06:45 +00:00
}
}
2014-11-13 20:04:05 +00:00
@Override
public int getProgress() {
return this.mProgress;
}
}