use of org.matrix.androidsdk.rest.model.message.MediaMessage in project matrix-android-sdk by matrix-org.
the class MXSession method removeMediasBefore.
/**
* Remove the medias older than the provided timestamp.
*
* @param context the context
* @param timestamp the timestamp (in seconds)
*/
public void removeMediasBefore(final Context context, final long timestamp) {
// list the files to keep even if they are older than the provided timestamp
// because their upload failed
final Set<String> filesToKeep = new HashSet<>();
IMXStore store = getDataHandler().getStore();
Collection<Room> rooms = store.getRooms();
for (Room room : rooms) {
Collection<Event> events = store.getRoomMessages(room.getRoomId());
if (null != events) {
for (Event event : events) {
try {
Message message = null;
if (TextUtils.equals(Event.EVENT_TYPE_MESSAGE, event.getType())) {
message = JsonUtils.toMessage(event.getContent());
} else if (TextUtils.equals(Event.EVENT_TYPE_STICKER, event.getType())) {
message = JsonUtils.toStickerMessage(event.getContent());
}
if (null != message && message instanceof MediaMessage) {
MediaMessage mediaMessage = (MediaMessage) message;
if (mediaMessage.isThumbnailLocalContent()) {
filesToKeep.add(Uri.parse(mediaMessage.getThumbnailUrl()).getPath());
}
if (mediaMessage.isLocalContent()) {
filesToKeep.add(Uri.parse(mediaMessage.getUrl()).getPath());
}
}
} catch (Exception e) {
Log.e(LOG_TAG, "## removeMediasBefore() : failed " + e.getMessage());
}
}
}
}
AsyncTask<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
long length = getMediasCache().removeMediasBefore(timestamp, filesToKeep);
// delete also the log files
// they might be large
File logsDir = Log.getLogDirectory();
if (null != logsDir) {
File[] logFiles = logsDir.listFiles();
if (null != logFiles) {
for (File file : logFiles) {
if (ContentUtils.getLastAccessTime(file) < timestamp) {
length += file.length();
file.delete();
}
}
}
}
if (0 != length) {
Log.d(LOG_TAG, "## removeMediasBefore() : save " + android.text.format.Formatter.formatFileSize(context, length));
} else {
Log.d(LOG_TAG, "## removeMediasBefore() : useless");
}
return null;
}
};
try {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} catch (Exception e) {
Log.e(LOG_TAG, "## removeMediasBefore() : failed " + e.getMessage());
task.cancel(true);
}
}
use of org.matrix.androidsdk.rest.model.message.MediaMessage in project matrix-android-sdk by matrix-org.
the class MatrixMessageListFragment method resend.
/**
* Resend an event.
*
* @param event the event to resend.
*/
protected void resend(final Event event) {
// should never happen but got it in a GA issue
if (null == event.eventId) {
Log.e(LOG_TAG, "resend : got an event with a null eventId");
return;
}
// check if the call is done in the right thread
if (Looper.getMainLooper().getThread() != Thread.currentThread()) {
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
resend(event);
}
});
return;
}
// update the timestamp
event.originServerTs = System.currentTimeMillis();
// remove the event
getSession().getDataHandler().deleteRoomEvent(event);
mAdapter.removeEventById(event.eventId);
mPendingRelaunchTimersByEventId.remove(event.eventId);
// send it again
final Message message = JsonUtils.toMessage(event.getContent());
final RoomMediaMessage roomMediaMessage = new RoomMediaMessage(new Event(message, mSession.getMyUserId(), mRoom.getRoomId()));
if (message instanceof MediaMessage) {
sendMediaMessage(roomMediaMessage);
} else {
// default case : text / emote
// skip the upload progress
mRoom.sendMediaMessage(roomMediaMessage, getMaxThumbnailWidth(), getMaxThumbnailHeight(), mEventCreationListener);
}
}
use of org.matrix.androidsdk.rest.model.message.MediaMessage in project matrix-android-sdk by matrix-org.
the class RoomMediaMessagesSender method uploadMedias.
// ==============================================================================================================
// Upload medias management
// ==============================================================================================================
/**
* Upload the medias.
*
* @param roomMediaMessage the roomMediaMessage
* @return true if a media is uploaded
*/
private boolean uploadMedias(final RoomMediaMessage roomMediaMessage) {
final Event event = roomMediaMessage.getEvent();
final Message message = JsonUtils.toMessage(event.getContent());
if (!(message instanceof MediaMessage)) {
return false;
}
final MediaMessage mediaMessage = (MediaMessage) message;
final String url;
final String fMimeType;
if (mediaMessage.isThumbnailLocalContent()) {
url = mediaMessage.getThumbnailUrl();
fMimeType = "image/jpeg";
} else if (mediaMessage.isLocalContent()) {
url = mediaMessage.getUrl();
fMimeType = mediaMessage.getMimeType();
} else {
return false;
}
mEncodingHandler.post(new Runnable() {
@Override
public void run() {
final MXMediasCache mediasCache = mDataHandler.getMediasCache();
Uri uri = Uri.parse(url);
String mimeType = fMimeType;
final MXEncryptedAttachments.EncryptionResult encryptionResult;
final Uri encryptedUri;
InputStream stream;
try {
stream = new FileInputStream(new File(uri.getPath()));
if (mRoom.isEncrypted() && mDataHandler.isCryptoEnabled() && (null != stream)) {
encryptionResult = MXEncryptedAttachments.encryptAttachment(stream, mimeType);
stream.close();
if (null != encryptionResult) {
mimeType = "application/octet-stream";
encryptedUri = Uri.parse(mediasCache.saveMedia(encryptionResult.mEncryptedStream, null, fMimeType));
File file = new File(encryptedUri.getPath());
stream = new FileInputStream(file);
} else {
skip();
mUiHandler.post(new Runnable() {
@Override
public void run() {
mDataHandler.updateEventState(roomMediaMessage.getEvent(), Event.SentState.UNDELIVERABLE);
mRoom.storeOutgoingEvent(roomMediaMessage.getEvent());
mDataHandler.getStore().commit();
roomMediaMessage.onEncryptionFailed();
}
});
return;
}
} else {
encryptionResult = null;
encryptedUri = null;
}
} catch (Exception e) {
skip();
return;
}
mDataHandler.updateEventState(roomMediaMessage.getEvent(), Event.SentState.SENDING);
mediasCache.uploadContent(stream, mediaMessage.isThumbnailLocalContent() ? ("thumb" + message.body) : message.body, mimeType, url, new MXMediaUploadListener() {
@Override
public void onUploadStart(final String uploadId) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
if (null != roomMediaMessage.getMediaUploadListener()) {
roomMediaMessage.getMediaUploadListener().onUploadStart(uploadId);
}
}
});
}
@Override
public void onUploadCancel(final String uploadId) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
mDataHandler.updateEventState(roomMediaMessage.getEvent(), Event.SentState.UNDELIVERABLE);
if (null != roomMediaMessage.getMediaUploadListener()) {
roomMediaMessage.getMediaUploadListener().onUploadCancel(uploadId);
roomMediaMessage.setMediaUploadListener(null);
roomMediaMessage.setEventSendingCallback(null);
}
skip();
}
});
}
@Override
public void onUploadError(final String uploadId, final int serverResponseCode, final String serverErrorMessage) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
mDataHandler.updateEventState(roomMediaMessage.getEvent(), Event.SentState.UNDELIVERABLE);
if (null != roomMediaMessage.getMediaUploadListener()) {
roomMediaMessage.getMediaUploadListener().onUploadError(uploadId, serverResponseCode, serverErrorMessage);
roomMediaMessage.setMediaUploadListener(null);
roomMediaMessage.setEventSendingCallback(null);
}
skip();
}
});
}
@Override
public void onUploadComplete(final String uploadId, final String contentUri) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
boolean isThumbnailUpload = mediaMessage.isThumbnailLocalContent();
if (isThumbnailUpload) {
mediaMessage.setThumbnailUrl(encryptionResult, contentUri);
if (null != encryptionResult) {
mediasCache.saveFileMediaForUrl(contentUri, encryptedUri.toString(), -1, -1, "image/jpeg");
try {
new File(Uri.parse(url).getPath()).delete();
} catch (Exception e) {
Log.e(LOG_TAG, "## cannot delete the uncompress media");
}
} else {
Pair<Integer, Integer> thumbnailSize = roomMediaMessage.getThumnailSize();
mediasCache.saveFileMediaForUrl(contentUri, url, thumbnailSize.first, thumbnailSize.second, "image/jpeg");
}
// update the event content with the new message info
event.updateContent(JsonUtils.toJson(message));
// force to save the room events list
// https://github.com/vector-im/riot-android/issues/1390
mDataHandler.getStore().flushRoomEvents(mRoom.getRoomId());
// upload the media
uploadMedias(roomMediaMessage);
} else {
if (null != encryptedUri) {
// replace the thumbnail and the media contents by the computed one
mediasCache.saveFileMediaForUrl(contentUri, encryptedUri.toString(), mediaMessage.getMimeType());
try {
new File(Uri.parse(url).getPath()).delete();
} catch (Exception e) {
Log.e(LOG_TAG, "## cannot delete the uncompress media");
}
} else {
// replace the thumbnail and the media contents by the computed one
mediasCache.saveFileMediaForUrl(contentUri, url, mediaMessage.getMimeType());
}
mediaMessage.setUrl(encryptionResult, contentUri);
// update the event content with the new message info
event.updateContent(JsonUtils.toJson(message));
// force to save the room events list
// https://github.com/vector-im/riot-android/issues/1390
mDataHandler.getStore().flushRoomEvents(mRoom.getRoomId());
Log.d(LOG_TAG, "Uploaded to " + contentUri);
// send
sendEvent(event);
}
if (null != roomMediaMessage.getMediaUploadListener()) {
roomMediaMessage.getMediaUploadListener().onUploadComplete(uploadId, contentUri);
if (!isThumbnailUpload) {
roomMediaMessage.setMediaUploadListener(null);
}
}
}
});
}
});
}
});
return true;
}
Aggregations