Examples with MXMediasCache org.matrix.androidsdk.db.MXMediasCache used on opensource projects

Example 1 with MXMediasCache

use of org.matrix.androidsdk.db.MXMediasCache in project matrix-android-sdk by matrix-org.

the class RoomMediaMessagesSender method buildImageMessage.

/**
 * Build an image message from a RoomMediaMessage.
 *
 * @param roomMediaMessage the roomMediaMessage
 * @return the image message
 */
private Message buildImageMessage(RoomMediaMessage roomMediaMessage) {
    try {
        String mimeType = roomMediaMessage.getMimeType(mContext);
        final MXMediasCache mediasCache = mDataHandler.getMediasCache();
        String mediaUrl = getMediaUrl(roomMediaMessage);
        // compute the thumbnail
        Bitmap thumbnailBitmap = roomMediaMessage.getFullScreenImageKindThumbnail(mContext);
        if (null == thumbnailBitmap) {
            thumbnailBitmap = getMediasPickerThumbnail(roomMediaMessage);
        }
        if (null == thumbnailBitmap) {
            Pair<Integer, Integer> thumbnailSize = roomMediaMessage.getThumnailSize();
            thumbnailBitmap = ResourceUtils.createThumbnailBitmap(mContext, roomMediaMessage.getUri(), thumbnailSize.first, thumbnailSize.second);
        }
        if (null == thumbnailBitmap) {
            thumbnailBitmap = roomMediaMessage.getMiniKindImageThumbnail(mContext);
        }
        String thumbnailURL = null;
        if (null != thumbnailBitmap) {
            thumbnailURL = mediasCache.saveBitmap(thumbnailBitmap, null);
        }
        // get the exif rotation angle
        final int rotationAngle = ImageUtils.getRotationAngleForBitmap(mContext, Uri.parse(mediaUrl));
        if (0 != rotationAngle) {
            // always apply the rotation to the image
            ImageUtils.rotateImage(mContext, thumbnailURL, rotationAngle, mediasCache);
        }
        ImageMessage imageMessage = new ImageMessage();
        imageMessage.url = mediaUrl;
        imageMessage.body = roomMediaMessage.getFileName(mContext);
        if (TextUtils.isEmpty(imageMessage.body)) {
            imageMessage.body = "Image";
        }
        Uri imageUri = Uri.parse(mediaUrl);
        if (null == imageMessage.info) {
            Room.fillImageInfo(mContext, imageMessage, imageUri, mimeType);
        }
        if ((null != thumbnailURL) && (null != imageMessage.info) && (null == imageMessage.info.thumbnailInfo)) {
            Uri thumbUri = Uri.parse(thumbnailURL);
            Room.fillThumbnailInfo(mContext, imageMessage, thumbUri, "image/jpeg");
            imageMessage.info.thumbnailUrl = thumbnailURL;
        }
        return imageMessage;
    } catch (Exception e) {
        Log.e(LOG_TAG, "## buildImageMessage() failed " + e.getMessage());
    }
    return null;
}

Example 2 with MXMediasCache

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

Example 3 with MXMediasCache

use of org.matrix.androidsdk.db.MXMediasCache in project matrix-android-sdk by matrix-org.

the class Room method cancelEventSending.

/**
 * Cancel the event sending.
 * Any media upload will be cancelled too.
 * The event becomes undeliverable.
 *
 * @param event the message
 */
public void cancelEventSending(final Event event) {
    if (null != event) {
        if ((Event.SentState.UNSENT == event.mSentState) || (Event.SentState.SENDING == event.mSentState) || (Event.SentState.WAITING_RETRY == event.mSentState) || (Event.SentState.ENCRYPTING == event.mSentState)) {
            // the message cannot be sent anymore
            mDataHandler.updateEventState(event, Event.SentState.UNDELIVERABLE);
        }
        List<String> urls = event.getMediaUrls();
        MXMediasCache cache = mDataHandler.getMediasCache();
        for (String url : urls) {
            cache.cancelUpload(url);
            cache.cancelDownload(cache.downloadIdFromUrl(url));
        }
    }
}