Examples with Message org.matrix.androidsdk.rest.model.message.Message used on opensource projects

Example 1 with Message

use of org.matrix.androidsdk.rest.model.message.Message in project matrix-android-sdk by matrix-org.

the class CryptoTest method buildTextEvent.

private Event buildTextEvent(String text, MXSession session) {
    Message message = new Message();
    message.msgtype = Message.MSGTYPE_TEXT;
    message.body = text;
    return new Event(message, session.getCredentials().userId, mRoomId);
}

Example 2 with Message

use of org.matrix.androidsdk.rest.model.message.Message 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);
    }
}

Example 3 with Message

use of org.matrix.androidsdk.rest.model.message.Message in project matrix-android-sdk by matrix-org.

the class RoomMediaMessagesSender method buildTextMessage.

// ==============================================================================================================
// Messages builder methods.
// ==============================================================================================================
/**
 * Build a text message from a RoomMediaMessage.
 *
 * @param roomMediaMessage the RoomMediaMessage.
 * @return the message
 */
private Message buildTextMessage(RoomMediaMessage roomMediaMessage) {
    CharSequence sequence = roomMediaMessage.getText();
    String htmlText = roomMediaMessage.getHtmlText();
    String text = null;
    if (null == sequence) {
        if (null != htmlText) {
            text = Html.fromHtml(htmlText).toString();
        }
    } else {
        text = sequence.toString();
    }
    // a text message cannot be null
    if (TextUtils.isEmpty(text) && !TextUtils.equals(roomMediaMessage.getMessageType(), Message.MSGTYPE_EMOTE)) {
        return null;
    }
    Message message = new Message();
    message.msgtype = (null == roomMediaMessage.getMessageType()) ? Message.MSGTYPE_TEXT : roomMediaMessage.getMessageType();
    message.body = text;
    // an emote can have an empty body
    if (null == message.body) {
        message.body = "";
    }
    if (!TextUtils.isEmpty(htmlText)) {
        message.formatted_body = htmlText;
        message.format = Message.FORMAT_MATRIX_HTML;
    }
    return message;
}

Example 4 with Message

use of org.matrix.androidsdk.rest.model.message.Message 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);
    }
}

Example 5 with Message

use of org.matrix.androidsdk.rest.model.message.Message 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;
}