Examples with MXMediaUploadListener org.matrix.androidsdk.listeners.MXMediaUploadListener used on opensource projects

Example 1 with MXMediaUploadListener

use of org.matrix.androidsdk.listeners.MXMediaUploadListener in project matrix-android-sdk by matrix-org.

the class MatrixMessageListFragment method sendMediaMessage.

/**
 * Send a media message in this room
 * @param roomMediaMessage the media message to send
 */
public void sendMediaMessage(final RoomMediaMessage roomMediaMessage) {
    mRoom.sendMediaMessage(roomMediaMessage, getMaxThumbnailWidth(), getMaxThumbnailHeight(), mEventCreationListener);
    roomMediaMessage.setMediaUploadListener(new MXMediaUploadListener() {

        @Override
        public void onUploadStart(String uploadId) {
            onMessageSendingSucceeded(roomMediaMessage.getEvent());
            mAdapter.notifyDataSetChanged();
        }

        @Override
        public void onUploadCancel(String uploadId) {
            onMessageSendingFailed(roomMediaMessage.getEvent());
            mAdapter.notifyDataSetChanged();
        }

        @Override
        public void onUploadError(final String uploadId, final int serverResponseCode, final String serverErrorMessage) {
            commonMediaUploadError(serverResponseCode, serverErrorMessage, mAdapter.getMessageRow(roomMediaMessage.getEvent().eventId));
        }

        @Override
        public void onUploadComplete(final String uploadId, final String contentUri) {
            Log.d(LOG_TAG, "Uploaded to " + contentUri);
        }
    });
}

Example 2 with MXMediaUploadListener

use of org.matrix.androidsdk.listeners.MXMediaUploadListener 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;
}