Conversations/src/main/java/eu/siacs/conversations/entities/Message.java

509 lines
13 KiB
Java
Raw Normal View History

2014-02-28 12:46:01 -05:00
package eu.siacs.conversations.entities;
2014-01-23 20:04:05 -05:00
import android.content.ContentValues;
import android.database.Cursor;
2014-10-13 19:06:45 -04:00
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
2014-08-31 12:21:46 -04:00
import eu.siacs.conversations.Config;
import eu.siacs.conversations.xmpp.jid.InvalidJidException;
import eu.siacs.conversations.xmpp.jid.Jid;
public class Message extends AbstractEntity {
2014-08-31 08:29:12 -04:00
2014-01-25 21:27:55 -05:00
public static final String TABLENAME = "messages";
2014-08-28 05:01:24 -04:00
public static final int STATUS_RECEIVED = 0;
public static final int STATUS_UNSEND = 1;
public static final int STATUS_SEND = 2;
2014-04-11 03:13:56 -04:00
public static final int STATUS_SEND_FAILED = 3;
2014-06-12 17:04:28 -04:00
public static final int STATUS_WAITING = 5;
public static final int STATUS_OFFERED = 6;
public static final int STATUS_SEND_RECEIVED = 7;
public static final int STATUS_SEND_DISPLAYED = 8;
public static final int ENCRYPTION_NONE = 0;
public static final int ENCRYPTION_PGP = 1;
public static final int ENCRYPTION_OTR = 2;
2014-02-27 18:22:56 -05:00
public static final int ENCRYPTION_DECRYPTED = 3;
2014-05-01 16:33:49 -04:00
public static final int ENCRYPTION_DECRYPTION_FAILED = 4;
2014-08-31 08:29:12 -04:00
2014-04-06 09:34:08 -04:00
public static final int TYPE_TEXT = 0;
public static final int TYPE_IMAGE = 1;
2014-11-13 15:04:05 -05:00
public static final int TYPE_FILE = 2;
public static final int TYPE_STATUS = 3;
public static final int TYPE_PRIVATE = 4;
public static String CONVERSATION = "conversationUuid";
public static String COUNTERPART = "counterpart";
public static String TRUE_COUNTERPART = "trueCounterpart";
public static String BODY = "body";
public static String TIME_SENT = "timeSent";
public static String ENCRYPTION = "encryption";
public static String STATUS = "status";
2014-04-06 09:34:08 -04:00
public static String TYPE = "type";
public static String REMOTE_MSG_ID = "remoteMsgId";
2014-11-13 15:04:05 -05:00
public static String RELATIVE_FILE_PATH = "relativeFilePath";
public boolean markable = false;
protected String conversationUuid;
protected Jid counterpart;
protected Jid trueCounterpart;
protected String body;
2014-04-03 11:39:57 -04:00
protected String encryptedBody;
protected long timeSent;
protected int encryption;
protected int status;
2014-04-06 09:34:08 -04:00
protected int type;
2014-11-13 15:04:05 -05:00
protected String relativeFilePath;
2014-02-10 16:45:59 -05:00
protected boolean read = true;
protected String remoteMsgId = null;
2014-10-07 10:02:52 -04:00
protected Conversation conversation = null;
protected Downloadable downloadable = null;
private Message mNextMessage = null;
private Message mPreviousMessage = null;
private Message() {
2014-08-31 08:29:12 -04:00
}
public Message(Conversation conversation, String body, int encryption) {
2014-11-18 08:49:49 -05:00
this(conversation, body, encryption, STATUS_UNSEND);
}
2014-08-31 08:29:12 -04:00
public Message(Conversation conversation, String body, int encryption, int status) {
2014-12-01 04:58:06 -05:00
this(java.util.UUID.randomUUID().toString(),
conversation.getUuid(),
conversation.getContactJid() == null ? null : conversation.getContactJid().toBareJid(),
null,
body,
System.currentTimeMillis(),
encryption,
status,
TYPE_TEXT,
null,
null);
2014-02-01 09:07:20 -05:00
this.conversation = conversation;
}
2014-08-31 08:29:12 -04:00
2014-12-01 04:58:06 -05:00
private Message(final String uuid, final String conversationUUid, final Jid counterpart,
final Jid trueCounterpart, final String body, final long timeSent,
2014-11-13 15:04:05 -05:00
final int encryption, final int status, final int type, final String remoteMsgId, final String relativeFilePath) {
this.uuid = uuid;
this.conversationUuid = conversationUUid;
this.counterpart = counterpart;
this.trueCounterpart = trueCounterpart;
this.body = body;
this.timeSent = timeSent;
this.encryption = encryption;
this.status = status;
2014-04-06 09:34:08 -04:00
this.type = type;
this.remoteMsgId = remoteMsgId;
2014-11-13 15:04:05 -05:00
this.relativeFilePath = relativeFilePath;
}
public static Message fromCursor(Cursor cursor) {
Jid jid;
try {
String value = cursor.getString(cursor.getColumnIndex(COUNTERPART));
2014-11-18 08:49:49 -05:00
if (value != null) {
jid = Jid.fromString(value);
} else {
jid = null;
}
} catch (InvalidJidException e) {
jid = null;
}
Jid trueCounterpart;
try {
String value = cursor.getString(cursor.getColumnIndex(TRUE_COUNTERPART));
2014-11-18 08:49:49 -05:00
if (value != null) {
trueCounterpart = Jid.fromString(value);
} else {
trueCounterpart = null;
}
} catch (InvalidJidException e) {
trueCounterpart = null;
}
return new Message(cursor.getString(cursor.getColumnIndex(UUID)),
cursor.getString(cursor.getColumnIndex(CONVERSATION)),
jid,
trueCounterpart,
cursor.getString(cursor.getColumnIndex(BODY)),
cursor.getLong(cursor.getColumnIndex(TIME_SENT)),
cursor.getInt(cursor.getColumnIndex(ENCRYPTION)),
cursor.getInt(cursor.getColumnIndex(STATUS)),
cursor.getInt(cursor.getColumnIndex(TYPE)),
2014-11-13 15:04:05 -05:00
cursor.getString(cursor.getColumnIndex(REMOTE_MSG_ID)),
cursor.getString(cursor.getColumnIndex(RELATIVE_FILE_PATH)));
}
public static Message createStatusMessage(Conversation conversation) {
Message message = new Message();
message.setType(Message.TYPE_STATUS);
message.setConversation(conversation);
return message;
}
@Override
public ContentValues getContentValues() {
ContentValues values = new ContentValues();
2014-01-28 13:21:54 -05:00
values.put(UUID, uuid);
values.put(CONVERSATION, conversationUuid);
if (counterpart == null) {
values.putNull(COUNTERPART);
} else {
values.put(COUNTERPART, counterpart.toString());
}
2014-11-18 08:49:49 -05:00
if (trueCounterpart == null) {
values.putNull(TRUE_COUNTERPART);
} else {
values.put(TRUE_COUNTERPART, trueCounterpart.toString());
}
values.put(BODY, body);
values.put(TIME_SENT, timeSent);
values.put(ENCRYPTION, encryption);
values.put(STATUS, status);
2014-04-06 09:34:08 -04:00
values.put(TYPE, type);
2014-08-31 08:29:12 -04:00
values.put(REMOTE_MSG_ID, remoteMsgId);
2014-11-13 15:04:05 -05:00
values.put(RELATIVE_FILE_PATH, relativeFilePath);
return values;
2014-01-23 20:04:05 -05:00
}
public String getConversationUuid() {
return conversationUuid;
}
2014-08-31 08:29:12 -04:00
public Conversation getConversation() {
return this.conversation;
}
public void setConversation(Conversation conv) {
this.conversation = conv;
}
public Jid getCounterpart() {
return counterpart;
}
2014-08-31 08:29:12 -04:00
public void setCounterpart(final Jid counterpart) {
this.counterpart = counterpart;
}
public Contact getContact() {
if (this.conversation.getMode() == Conversation.MODE_SINGLE) {
return this.conversation.getContact();
} else {
if (this.trueCounterpart == null) {
return null;
} else {
return this.conversation.getAccount().getRoster()
.getContactFromRoster(this.trueCounterpart);
}
}
}
2014-08-31 10:28:21 -04:00
public String getBody() {
return body;
}
2014-08-31 08:29:12 -04:00
public void setBody(String body) {
this.body = body;
}
public long getTimeSent() {
return timeSent;
}
public int getEncryption() {
return encryption;
}
public void setEncryption(int encryption) {
this.encryption = encryption;
}
public int getStatus() {
return status;
2014-01-23 20:04:05 -05:00
}
2014-08-31 08:29:12 -04:00
public void setStatus(int status) {
this.status = status;
}
2014-11-18 08:49:49 -05:00
public String getRelativeFilePath() {
return this.relativeFilePath;
2014-11-13 15:04:05 -05:00
}
2014-11-18 08:49:49 -05:00
public void setRelativeFilePath(String path) {
this.relativeFilePath = path;
2014-11-13 15:04:05 -05:00
}
public String getRemoteMsgId() {
return this.remoteMsgId;
}
2014-08-31 08:29:12 -04:00
public void setRemoteMsgId(String id) {
this.remoteMsgId = id;
}
2014-01-23 20:04:05 -05:00
2014-02-10 16:45:59 -05:00
public boolean isRead() {
return this.read;
}
2014-08-31 08:29:12 -04:00
2014-02-10 16:45:59 -05:00
public void markRead() {
this.read = true;
}
2014-08-31 08:29:12 -04:00
2014-02-10 16:45:59 -05:00
public void markUnread() {
this.read = false;
}
public void setTime(long time) {
this.timeSent = time;
}
2014-02-16 10:32:15 -05:00
2014-04-03 11:39:57 -04:00
public String getEncryptedBody() {
return this.encryptedBody;
}
2014-08-31 08:29:12 -04:00
2014-04-03 11:39:57 -04:00
public void setEncryptedBody(String body) {
this.encryptedBody = body;
}
2014-04-06 09:34:08 -04:00
public int getType() {
return this.type;
}
public void setType(int type) {
this.type = type;
}
2014-08-31 08:29:12 -04:00
public void setTrueCounterpart(Jid trueCounterpart) {
this.trueCounterpart = trueCounterpart;
}
2014-08-31 08:29:12 -04:00
public Downloadable getDownloadable() {
return this.downloadable;
}
2014-08-31 08:29:12 -04:00
public void setDownloadable(Downloadable downloadable) {
this.downloadable = downloadable;
}
2014-08-31 08:29:12 -04:00
2014-08-23 09:57:39 -04:00
public boolean equals(Message message) {
2014-11-18 08:49:49 -05:00
return (this.remoteMsgId != null) && (this.body != null) && (this.counterpart != null) && this.remoteMsgId.equals(message.getRemoteMsgId()) && this.body.equals(message.getBody()) && this.counterpart.equals(message.getCounterpart());
2014-08-31 08:29:12 -04:00
}
public Message next() {
if (this.mNextMessage == null) {
synchronized (this.conversation.messages) {
int index = this.conversation.messages.indexOf(this);
if (index < 0
|| index >= this.conversation.getMessages().size() - 1) {
this.mNextMessage = null;
} else {
this.mNextMessage = this.conversation.messages
.get(index + 1);
}
}
2014-08-31 08:29:12 -04:00
}
return this.mNextMessage;
2014-08-31 08:29:12 -04:00
}
public Message prev() {
if (this.mPreviousMessage == null) {
synchronized (this.conversation.messages) {
int index = this.conversation.messages.indexOf(this);
if (index <= 0 || index > this.conversation.messages.size()) {
this.mPreviousMessage = null;
} else {
this.mPreviousMessage = this.conversation.messages
.get(index - 1);
}
}
2014-08-31 08:29:12 -04:00
}
return this.mPreviousMessage;
2014-08-31 08:29:12 -04:00
}
2014-11-18 08:49:49 -05:00
public boolean mergeable(final Message message) {
return message != null && (message.getType() == Message.TYPE_TEXT && this.getDownloadable() == null && message.getDownloadable() == null && message.getEncryption() != Message.ENCRYPTION_PGP && this.getType() == message.getType() && this.getStatus() == message.getStatus() && this.getEncryption() == message.getEncryption() && this.getCounterpart() != null && this.getCounterpart().equals(message.getCounterpart()) && (message.getTimeSent() - this.getTimeSent()) <= (Config.MESSAGE_MERGE_WINDOW * 1000) && !message.bodyContainsDownloadable() && !this.bodyContainsDownloadable());
2014-08-31 08:29:12 -04:00
}
public String getMergedBody() {
Message next = this.next();
2014-11-01 09:33:34 -04:00
if (this.mergeable(next)) {
2014-08-31 08:29:12 -04:00
return body.trim() + '\n' + next.getMergedBody();
}
return body.trim();
}
public int getMergedStatus() {
2014-11-18 08:49:49 -05:00
return getStatus();
}
public long getMergedTimeSent() {
Message next = this.next();
2014-11-01 09:33:34 -04:00
if (this.mergeable(next)) {
return next.getMergedTimeSent();
} else {
return getTimeSent();
}
}
2014-08-31 08:29:12 -04:00
public boolean wasMergedIntoPrevious() {
Message prev = this.prev();
return prev != null && prev.mergeable(this);
2014-08-23 09:57:39 -04:00
}
public boolean trusted() {
Contact contact = this.getContact();
return (status > STATUS_RECEIVED || (contact != null && contact.trusted()));
}
2014-10-13 19:06:45 -04:00
public boolean bodyContainsDownloadable() {
try {
URL url = new URL(this.getBody());
if (!url.getProtocol().equalsIgnoreCase("http")
&& !url.getProtocol().equalsIgnoreCase("https")) {
2014-10-13 19:06:45 -04:00
return false;
}
if (url.getPath() == null) {
2014-10-13 19:06:45 -04:00
return false;
}
String[] pathParts = url.getPath().split("/");
2014-10-27 16:47:17 -04:00
String filename;
if (pathParts.length > 0) {
filename = pathParts[pathParts.length - 1];
} else {
2014-11-01 09:33:34 -04:00
return false;
2014-10-27 16:47:17 -04:00
}
2014-10-13 19:06:45 -04:00
String[] extensionParts = filename.split("\\.");
if (extensionParts.length == 2
2014-11-13 15:04:05 -05:00
&& Arrays.asList(Downloadable.VALID_IMAGE_EXTENSIONS).contains(
extensionParts[extensionParts.length - 1])) {
2014-10-13 19:06:45 -04:00
return true;
} else if (extensionParts.length == 3
&& Arrays
.asList(Downloadable.VALID_CRYPTO_EXTENSIONS)
.contains(extensionParts[extensionParts.length - 1])
2014-11-13 15:04:05 -05:00
&& Arrays.asList(Downloadable.VALID_IMAGE_EXTENSIONS).contains(
extensionParts[extensionParts.length - 2])) {
2014-10-13 19:06:45 -04:00
return true;
} else {
return false;
}
} catch (MalformedURLException e) {
return false;
}
}
2014-10-14 12:16:03 -04:00
public ImageParams getImageParams() {
ImageParams params = getLegacyImageParams();
if (params != null) {
return params;
}
params = new ImageParams();
if (this.downloadable != null) {
params.size = this.downloadable.getFileSize();
}
if (body == null) {
2014-10-14 12:16:03 -04:00
return params;
}
String parts[] = body.split("\\|");
if (parts.length == 1) {
2014-10-14 12:16:03 -04:00
try {
params.size = Long.parseLong(parts[0]);
} catch (NumberFormatException e) {
params.origin = parts[0];
try {
params.url = new URL(parts[0]);
} catch (MalformedURLException e1) {
params.url = null;
}
2014-10-14 12:16:03 -04:00
}
} else if (parts.length == 3) {
2014-10-14 12:16:03 -04:00
try {
params.size = Long.parseLong(parts[0]);
} catch (NumberFormatException e) {
params.size = 0;
}
try {
params.width = Integer.parseInt(parts[1]);
} catch (NumberFormatException e) {
params.width = 0;
}
try {
params.height = Integer.parseInt(parts[2]);
} catch (NumberFormatException e) {
params.height = 0;
}
} else if (parts.length == 4) {
params.origin = parts[0];
try {
params.url = new URL(parts[0]);
} catch (MalformedURLException e1) {
params.url = null;
}
2014-10-14 12:16:03 -04:00
try {
params.size = Long.parseLong(parts[1]);
} catch (NumberFormatException e) {
params.size = 0;
}
try {
params.width = Integer.parseInt(parts[2]);
} catch (NumberFormatException e) {
params.width = 0;
}
try {
params.height = Integer.parseInt(parts[3]);
} catch (NumberFormatException e) {
params.height = 0;
}
}
return params;
}
public ImageParams getLegacyImageParams() {
ImageParams params = new ImageParams();
if (body == null) {
return params;
}
String parts[] = body.split(",");
if (parts.length == 3) {
try {
params.size = Long.parseLong(parts[0]);
} catch (NumberFormatException e) {
return null;
}
try {
params.width = Integer.parseInt(parts[1]);
} catch (NumberFormatException e) {
return null;
}
try {
params.height = Integer.parseInt(parts[2]);
} catch (NumberFormatException e) {
return null;
}
return params;
} else {
return null;
}
}
public void untie() {
this.mNextMessage = null;
this.mPreviousMessage = null;
}
2014-10-14 12:16:03 -04:00
public class ImageParams {
public URL url;
2014-10-14 12:16:03 -04:00
public long size = 0;
public int width = 0;
public int height = 0;
public String origin;
}
2014-01-23 20:04:05 -05:00
}