mirror of
https://github.com/oxen-io/session-android.git
synced 2024-11-29 04:55:15 +00:00
377 lines
14 KiB
Java
377 lines
14 KiB
Java
/**
|
|
* Copyright (C) 2011 Whisper Systems
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.thoughtcrime.securesms.mms;
|
|
|
|
import android.app.Activity;
|
|
import android.content.ActivityNotFoundException;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.graphics.Bitmap;
|
|
import android.net.Uri;
|
|
import android.os.AsyncTask;
|
|
import android.os.Build;
|
|
import android.provider.ContactsContract;
|
|
import android.provider.MediaStore;
|
|
import android.support.annotation.NonNull;
|
|
import android.support.annotation.Nullable;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.widget.Toast;
|
|
|
|
import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
|
|
import com.google.android.gms.common.GooglePlayServicesRepairableException;
|
|
import com.google.android.gms.location.places.ui.PlacePicker;
|
|
|
|
import org.thoughtcrime.securesms.MediaPreviewActivity;
|
|
import org.thoughtcrime.securesms.R;
|
|
import org.thoughtcrime.securesms.components.AudioView;
|
|
import org.thoughtcrime.securesms.components.RemovableMediaView;
|
|
import org.thoughtcrime.securesms.components.ThumbnailView;
|
|
import org.thoughtcrime.securesms.components.location.SignalMapView;
|
|
import org.thoughtcrime.securesms.components.location.SignalPlace;
|
|
import org.thoughtcrime.securesms.crypto.MasterSecret;
|
|
import org.thoughtcrime.securesms.providers.PersistentBlobProvider;
|
|
import org.thoughtcrime.securesms.util.BitmapUtil;
|
|
import org.thoughtcrime.securesms.util.MediaUtil;
|
|
import org.thoughtcrime.securesms.util.ViewUtil;
|
|
import org.thoughtcrime.securesms.util.concurrent.AssertedSuccessListener;
|
|
import org.thoughtcrime.securesms.util.concurrent.ListenableFuture;
|
|
import org.thoughtcrime.securesms.util.concurrent.ListenableFuture.Listener;
|
|
import org.whispersystems.libaxolotl.util.guava.Optional;
|
|
|
|
import java.io.IOException;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.concurrent.ExecutionException;
|
|
|
|
import ws.com.google.android.mms.ContentType;
|
|
|
|
public class AttachmentManager {
|
|
|
|
private final static String TAG = AttachmentManager.class.getSimpleName();
|
|
|
|
private final @NonNull Context context;
|
|
private final @NonNull View attachmentView;
|
|
private final @NonNull RemovableMediaView removableMediaView;
|
|
private final @NonNull ThumbnailView thumbnail;
|
|
private final @NonNull AudioView audioView;
|
|
private final @NonNull SignalMapView mapView;
|
|
private final @NonNull AttachmentListener attachmentListener;
|
|
|
|
private @NonNull List<Uri> garbage = new LinkedList<>();
|
|
private @NonNull Optional<Slide> slide = Optional.absent();
|
|
private @Nullable Uri captureUri;
|
|
|
|
public AttachmentManager(@NonNull Activity activity, @NonNull AttachmentListener listener) {
|
|
this.attachmentView = ViewUtil.findById(activity, R.id.attachment_editor);
|
|
this.thumbnail = ViewUtil.findById(activity, R.id.attachment_thumbnail);
|
|
this.audioView = ViewUtil.findById(activity, R.id.attachment_audio);
|
|
this.mapView = ViewUtil.findById(activity, R.id.attachment_location);
|
|
this.removableMediaView = ViewUtil.findById(activity, R.id.removable_media_view);
|
|
this.context = activity;
|
|
this.attachmentListener = listener;
|
|
|
|
removableMediaView.setRemoveClickListener(new RemoveButtonListener());
|
|
thumbnail.setOnClickListener(new ThumbnailClickListener());
|
|
}
|
|
|
|
public void clear() {
|
|
ViewUtil.fadeOut(attachmentView, 200).addListener(new Listener<Boolean>() {
|
|
@Override
|
|
public void onSuccess(Boolean result) {
|
|
thumbnail.clear();
|
|
attachmentView.setVisibility(View.GONE);
|
|
attachmentListener.onAttachmentChanged();
|
|
}
|
|
|
|
@Override
|
|
public void onFailure(ExecutionException e) {}
|
|
});
|
|
|
|
markGarbage(getSlideUri());
|
|
slide = Optional.absent();
|
|
audioView.cleanup();
|
|
}
|
|
|
|
public void cleanup() {
|
|
cleanup(captureUri);
|
|
cleanup(getSlideUri());
|
|
|
|
captureUri = null;
|
|
slide = Optional.absent();
|
|
|
|
Iterator<Uri> iterator = garbage.listIterator();
|
|
|
|
while (iterator.hasNext()) {
|
|
cleanup(iterator.next());
|
|
iterator.remove();
|
|
}
|
|
}
|
|
|
|
private void cleanup(final @Nullable Uri uri) {
|
|
if (uri != null && PersistentBlobProvider.isAuthority(context, uri)) {
|
|
Log.w(TAG, "cleaning up " + uri);
|
|
PersistentBlobProvider.getInstance(context).delete(uri);
|
|
}
|
|
}
|
|
|
|
private void markGarbage(@Nullable Uri uri) {
|
|
if (uri != null && PersistentBlobProvider.isAuthority(context, uri)) {
|
|
Log.w(TAG, "Marking garbage that needs cleaning: " + uri);
|
|
garbage.add(uri);
|
|
}
|
|
}
|
|
|
|
private void setSlide(@NonNull Slide slide) {
|
|
if (getSlideUri() != null) cleanup(getSlideUri());
|
|
if (captureUri != null && !captureUri.equals(slide.getUri())) cleanup(captureUri);
|
|
|
|
this.captureUri = null;
|
|
this.slide = Optional.of(slide);
|
|
}
|
|
|
|
public void setLocation(@NonNull final MasterSecret masterSecret,
|
|
@NonNull final SignalPlace place,
|
|
@NonNull final MediaConstraints constraints)
|
|
{
|
|
ListenableFuture<Bitmap> future = mapView.display(place);
|
|
|
|
attachmentView.setVisibility(View.VISIBLE);
|
|
removableMediaView.display(mapView);
|
|
|
|
future.addListener(new AssertedSuccessListener<Bitmap>() {
|
|
@Override
|
|
public void onSuccess(@NonNull Bitmap result) {
|
|
byte[] blob = BitmapUtil.toByteArray(result);
|
|
Uri uri = PersistentBlobProvider.getInstance(context)
|
|
.create(masterSecret, blob, ContentType.IMAGE_PNG);
|
|
LocationSlide locationSlide = new LocationSlide(context, uri, blob.length, place);
|
|
|
|
setSlide(locationSlide);
|
|
attachmentListener.onAttachmentChanged();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setMedia(@NonNull final MasterSecret masterSecret,
|
|
@NonNull final Uri uri,
|
|
@NonNull final MediaType mediaType,
|
|
@NonNull final MediaConstraints constraints)
|
|
{
|
|
new AsyncTask<Void, Void, Slide>() {
|
|
@Override
|
|
protected void onPreExecute() {
|
|
thumbnail.clear();
|
|
thumbnail.showProgressSpinner();
|
|
attachmentView.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
@Override
|
|
protected @Nullable Slide doInBackground(Void... params) {
|
|
long start = System.currentTimeMillis();
|
|
try {
|
|
final long mediaSize = MediaUtil.getMediaSize(context, masterSecret, uri);
|
|
final Slide slide = mediaType.createSlide(context, uri, mediaSize);
|
|
Log.w(TAG, "slide with size " + mediaSize + " took " + (System.currentTimeMillis() - start) + "ms");
|
|
return slide;
|
|
} catch (IOException ioe) {
|
|
Log.w(TAG, ioe);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onPostExecute(@Nullable final Slide slide) {
|
|
if (slide == null) {
|
|
attachmentView.setVisibility(View.GONE);
|
|
Toast.makeText(context,
|
|
R.string.ConversationActivity_sorry_there_was_an_error_setting_your_attachment,
|
|
Toast.LENGTH_SHORT).show();
|
|
} else if (!areConstraintsSatisfied(context, masterSecret, slide, constraints)) {
|
|
attachmentView.setVisibility(View.GONE);
|
|
Toast.makeText(context,
|
|
R.string.ConversationActivity_attachment_exceeds_size_limits,
|
|
Toast.LENGTH_SHORT).show();
|
|
} else {
|
|
setSlide(slide);
|
|
attachmentView.setVisibility(View.VISIBLE);
|
|
|
|
if (slide.hasAudio()) {
|
|
audioView.setAudio(masterSecret, (AudioSlide)slide, false);
|
|
removableMediaView.display(audioView);
|
|
} else {
|
|
thumbnail.setImageResource(masterSecret, slide, false);
|
|
removableMediaView.display(thumbnail);
|
|
}
|
|
|
|
attachmentListener.onAttachmentChanged();
|
|
}
|
|
}
|
|
}.execute();
|
|
}
|
|
|
|
public boolean isAttachmentPresent() {
|
|
return attachmentView.getVisibility() == View.VISIBLE;
|
|
}
|
|
|
|
public @NonNull SlideDeck buildSlideDeck() {
|
|
SlideDeck deck = new SlideDeck();
|
|
if (slide.isPresent()) deck.addSlide(slide.get());
|
|
return deck;
|
|
}
|
|
|
|
public static void selectVideo(Activity activity, int requestCode) {
|
|
selectMediaType(activity, "video/*", requestCode);
|
|
}
|
|
|
|
public static void selectImage(Activity activity, int requestCode) {
|
|
selectMediaType(activity, "image/*", requestCode);
|
|
}
|
|
|
|
public static void selectAudio(Activity activity, int requestCode) {
|
|
selectMediaType(activity, "audio/*", requestCode);
|
|
}
|
|
|
|
public static void selectContactInfo(Activity activity, int requestCode) {
|
|
Intent intent = new Intent(Intent.ACTION_PICK, ContactsContract.Contacts.CONTENT_URI);
|
|
activity.startActivityForResult(intent, requestCode);
|
|
}
|
|
|
|
public static void selectLocation(Activity activity, int requestCode) {
|
|
try {
|
|
activity.startActivityForResult(new PlacePicker.IntentBuilder().build(activity), requestCode);
|
|
} catch (GooglePlayServicesRepairableException | GooglePlayServicesNotAvailableException e) {
|
|
Log.w(TAG, e);
|
|
}
|
|
}
|
|
|
|
private @Nullable Uri getSlideUri() {
|
|
return slide.isPresent() ? slide.get().getUri() : null;
|
|
}
|
|
|
|
public @Nullable Uri getCaptureUri() {
|
|
return captureUri;
|
|
}
|
|
|
|
public void capturePhoto(Activity activity, int requestCode) {
|
|
try {
|
|
Intent captureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
|
|
if (captureIntent.resolveActivity(activity.getPackageManager()) != null) {
|
|
if (captureUri == null) {
|
|
captureUri = PersistentBlobProvider.getInstance(context)
|
|
.createForExternal(ContentType.IMAGE_JPEG);
|
|
}
|
|
Log.w(TAG, "captureUri path is " + captureUri.getPath());
|
|
captureIntent.putExtra(MediaStore.EXTRA_OUTPUT, captureUri);
|
|
activity.startActivityForResult(captureIntent, requestCode);
|
|
}
|
|
} catch (IOException ioe) {
|
|
Log.w(TAG, ioe);
|
|
}
|
|
}
|
|
|
|
private static void selectMediaType(Activity activity, String type, int requestCode) {
|
|
final Intent intent = new Intent();
|
|
intent.setType(type);
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
|
|
intent.setAction(Intent.ACTION_OPEN_DOCUMENT);
|
|
try {
|
|
activity.startActivityForResult(intent, requestCode);
|
|
return;
|
|
} catch (ActivityNotFoundException anfe) {
|
|
Log.w(TAG, "couldn't complete ACTION_OPEN_DOCUMENT, no activity found. falling back.");
|
|
}
|
|
}
|
|
|
|
intent.setAction(Intent.ACTION_GET_CONTENT);
|
|
try {
|
|
activity.startActivityForResult(intent, requestCode);
|
|
} catch (ActivityNotFoundException anfe) {
|
|
Log.w(TAG, "couldn't complete ACTION_GET_CONTENT intent, no activity found. falling back.");
|
|
Toast.makeText(activity, R.string.AttachmentManager_cant_open_media_selection, Toast.LENGTH_LONG).show();
|
|
}
|
|
}
|
|
|
|
private boolean areConstraintsSatisfied(final @NonNull Context context,
|
|
final @NonNull MasterSecret masterSecret,
|
|
final @Nullable Slide slide,
|
|
final @NonNull MediaConstraints constraints)
|
|
{
|
|
return slide == null ||
|
|
constraints.isSatisfied(context, masterSecret, slide.asAttachment()) ||
|
|
constraints.canResize(slide.asAttachment());
|
|
}
|
|
|
|
private void previewImageDraft(final @NonNull Slide slide) {
|
|
if (MediaPreviewActivity.isContentTypeSupported(slide.getContentType()) && slide.getThumbnailUri() != null) {
|
|
Intent intent = new Intent(context, MediaPreviewActivity.class);
|
|
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
|
|
intent.setDataAndType(slide.getUri(), slide.getContentType());
|
|
|
|
context.startActivity(intent);
|
|
}
|
|
}
|
|
|
|
private class ThumbnailClickListener implements View.OnClickListener {
|
|
@Override
|
|
public void onClick(View v) {
|
|
if (slide.isPresent()) previewImageDraft(slide.get());
|
|
}
|
|
}
|
|
|
|
private class RemoveButtonListener implements View.OnClickListener {
|
|
@Override
|
|
public void onClick(View v) {
|
|
cleanup();
|
|
clear();
|
|
}
|
|
}
|
|
|
|
public interface AttachmentListener {
|
|
void onAttachmentChanged();
|
|
}
|
|
|
|
public enum MediaType {
|
|
IMAGE, GIF, AUDIO, VIDEO;
|
|
|
|
public @NonNull Slide createSlide(@NonNull Context context,
|
|
@NonNull Uri uri,
|
|
long dataSize)
|
|
{
|
|
switch (this) {
|
|
case IMAGE: return new ImageSlide(context, uri, dataSize);
|
|
case GIF: return new GifSlide(context, uri, dataSize);
|
|
case AUDIO: return new AudioSlide(context, uri, dataSize);
|
|
case VIDEO: return new VideoSlide(context, uri, dataSize);
|
|
default: throw new AssertionError("unrecognized enum");
|
|
}
|
|
}
|
|
|
|
public static @Nullable MediaType from(final @Nullable String mimeType) {
|
|
if (TextUtils.isEmpty(mimeType)) return null;
|
|
if (MediaUtil.isGif(mimeType)) return GIF;
|
|
if (ContentType.isImageType(mimeType)) return IMAGE;
|
|
if (ContentType.isAudioType(mimeType)) return AUDIO;
|
|
if (ContentType.isVideoType(mimeType)) return VIDEO;
|
|
return null;
|
|
}
|
|
}
|
|
}
|