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

290 lines
8.1 KiB
Java
Raw Normal View History

2014-10-13 23:06:45 +00:00
package eu.siacs.conversations.http;
import android.content.Intent;
import android.graphics.BitmapFactory;
import android.net.Uri;
import org.apache.http.conn.ssl.StrictHostnameVerifier;
2014-10-13 23:06:45 +00:00
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
2014-10-19 21:42:53 +00:00
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
2014-10-13 23:06:45 +00:00
import javax.net.ssl.HostnameVerifier;
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.SSLContext;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.X509TrustManager;
2014-10-13 23:06:45 +00:00
import eu.siacs.conversations.entities.Downloadable;
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;
import eu.siacs.conversations.services.XmppConnectionService;
import eu.siacs.conversations.utils.CryptoHelper;
2014-10-13 23:06:45 +00:00
public class HttpConnection implements Downloadable {
private HttpConnectionManager mHttpConnectionManager;
private XmppConnectionService mXmppConnectionService;
private URL mUrl;
private Message message;
private DownloadableFile file;
private int mStatus = Downloadable.STATUS_UNKNOWN;
private boolean acceptedAutomatically = false;
2014-11-13 20:04:05 +00:00
private int mProgress = 0;
2014-10-13 23:06:45 +00:00
public HttpConnection(HttpConnectionManager manager) {
this.mHttpConnectionManager = manager;
this.mXmppConnectionService = manager.getXmppConnectionService();
}
@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) {
this.message = message;
this.message.setDownloadable(this);
try {
mUrl = new URL(message.getBody());
String path = mUrl.getPath();
if (path != null && (path.endsWith(".pgp") || path.endsWith(".gpg"))) {
this.message.setEncryption(Message.ENCRYPTION_PGP);
} else if (message.getEncryption() != Message.ENCRYPTION_OTR) {
this.message.setEncryption(Message.ENCRYPTION_NONE);
}
2014-10-19 21:42:53 +00:00
this.file = mXmppConnectionService.getFileBackend().getFile(
message, false);
String reference = mUrl.getRef();
if (reference != null && reference.length() == 96) {
this.file.setKey(CryptoHelper.hexToBytes(reference));
}
if (this.message.getEncryption() == Message.ENCRYPTION_OTR
&& this.file.getKey() == null) {
this.message.setEncryption(Message.ENCRYPTION_NONE);
}
2014-10-19 21:42:53 +00:00
checkFileSize(false);
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
}
public void cancel() {
mHttpConnectionManager.finishConnection(this);
message.setDownloadable(null);
mXmppConnectionService.updateConversationUi();
}
private void finish() {
Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
intent.setData(Uri.fromFile(file));
mXmppConnectionService.sendBroadcast(intent);
message.setDownloadable(null);
mHttpConnectionManager.finishConnection(this);
mXmppConnectionService.updateConversationUi();
if (acceptedAutomatically) {
mXmppConnectionService.getNotificationService().push(message);
}
2014-10-13 23:06:45 +00:00
}
private void changeStatus(int status) {
this.mStatus = status;
mXmppConnectionService.updateConversationUi();
}
private void setupTrustManager(HttpsURLConnection connection,
boolean interactive) {
2014-10-19 21:42:53 +00:00
X509TrustManager trustManager;
HostnameVerifier hostnameVerifier;
2014-10-19 21:42:53 +00:00
if (interactive) {
trustManager = mXmppConnectionService.getMemorizingTrustManager();
hostnameVerifier = mXmppConnectionService
.getMemorizingTrustManager().wrapHostnameVerifier(
new StrictHostnameVerifier());
2014-10-19 21:42:53 +00:00
} else {
trustManager = mXmppConnectionService.getMemorizingTrustManager()
.getNonInteractive();
hostnameVerifier = mXmppConnectionService
.getMemorizingTrustManager()
.wrapHostnameVerifierNonInteractive(
new StrictHostnameVerifier());
2014-10-19 21:42:53 +00:00
}
try {
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, new X509TrustManager[]{trustManager},
mXmppConnectionService.getRNG());
2014-10-19 21:42:53 +00:00
connection.setSSLSocketFactory(sc.getSocketFactory());
connection.setHostnameVerifier(hostnameVerifier);
2014-10-19 21:42:53 +00:00
} catch (KeyManagementException e) {
return;
} catch (NoSuchAlgorithmException e) {
return;
}
}
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();
2014-10-19 21:42:53 +00:00
} catch (SSLHandshakeException e) {
changeStatus(STATUS_OFFER_CHECK_FILESIZE);
HttpConnection.this.acceptedAutomatically = false;
HttpConnection.this.mXmppConnectionService.getNotificationService().push(message);
2014-10-19 21:42:53 +00:00
return;
2014-10-13 23:06:45 +00:00
} catch (IOException e) {
cancel();
return;
}
file.setExpectedSize(size);
if (size <= mHttpConnectionManager.getAutoAcceptFileSize()) {
HttpConnection.this.acceptedAutomatically = true;
new Thread(new FileDownloader(interactive)).start();
} else {
changeStatus(STATUS_OFFER);
HttpConnection.this.acceptedAutomatically = false;
HttpConnection.this.mXmppConnectionService.getNotificationService().push(message);
2014-10-13 23:06:45 +00:00
}
}
private long retrieveFileSize() throws IOException,
SSLHandshakeException {
changeStatus(STATUS_CHECKING);
HttpURLConnection connection = (HttpURLConnection) mUrl
.openConnection();
2014-10-13 23:06:45 +00:00
connection.setRequestMethod("HEAD");
if (connection instanceof HttpsURLConnection) {
2014-10-19 21:42:53 +00:00
setupTrustManager((HttpsURLConnection) connection, interactive);
2014-10-13 23:06:45 +00:00
}
2014-10-19 21:42:53 +00:00
connection.connect();
2014-10-13 23:06:45 +00:00
String contentLength = connection.getHeaderField("Content-Length");
if (contentLength == null) {
throw new IOException();
}
try {
return Long.parseLong(contentLength, 10);
} catch (NumberFormatException e) {
throw new IOException();
}
}
}
2014-10-13 23:06:45 +00:00
private class FileDownloader implements Runnable {
private boolean interactive = false;
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);
2014-10-13 23:06:45 +00:00
} catch (IOException e) {
cancel();
}
}
private void download() throws SSLHandshakeException, IOException {
HttpURLConnection connection = (HttpURLConnection) mUrl
.openConnection();
2014-10-13 23:06:45 +00:00
if (connection instanceof HttpsURLConnection) {
setupTrustManager((HttpsURLConnection) connection, interactive);
2014-10-13 23:06:45 +00:00
}
connection.connect();
BufferedInputStream is = new BufferedInputStream(
connection.getInputStream());
file.getParentFile().mkdirs();
file.createNewFile();
2014-10-13 23:06:45 +00:00
OutputStream os = file.createOutputStream();
if (os == null) {
throw new IOException();
}
2014-11-13 20:04:05 +00:00
long transmitted = 0;
long expected = file.getExpectedSize();
2014-10-13 23:06:45 +00:00
int count = -1;
byte[] buffer = new byte[1024];
while ((count = is.read(buffer)) != -1) {
2014-11-13 20:04:05 +00:00
transmitted += count;
2014-10-13 23:06:45 +00:00
os.write(buffer, 0, count);
2014-11-13 20:04:05 +00:00
mProgress = (int) (expected * 100 / transmitted);
2014-10-13 23:06:45 +00:00
}
os.flush();
os.close();
is.close();
2014-10-14 16:16:03 +00:00
}
2014-10-14 16:16:03 +00:00
private void updateImageBounds() {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(file.getAbsolutePath(), options);
int imageHeight = options.outHeight;
int imageWidth = options.outWidth;
message.setBody(mUrl.toString() + "|" + file.getSize() + '|'
+ imageWidth + '|' + imageHeight);
message.setType(Message.TYPE_IMAGE);
mXmppConnectionService.updateMessage(message);
}
}
@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;
}
@Override
public String getMimeType() {
return "";
}
2014-10-13 23:06:45 +00:00
}