608 lines
24 KiB
Java
608 lines
24 KiB
Java
/*
|
|
* Copyright (c) 2022 Proton AG
|
|
*
|
|
* This file is part of Proton Mail.
|
|
*
|
|
* Proton Mail 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.
|
|
*
|
|
* Proton Mail 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 Proton Mail. If not, see https://www.gnu.org/licenses/.
|
|
*/
|
|
package ch.protonmail.android.activities;
|
|
|
|
import static ch.protonmail.android.attachments.ImportAttachmentsWorkerKt.KEY_INPUT_DATA_DELETE_ORIGINAL_FILE_BOOLEAN;
|
|
import static ch.protonmail.android.attachments.ImportAttachmentsWorkerKt.KEY_INPUT_DATA_FILE_URIS_STRING_ARRAY;
|
|
|
|
import android.app.Activity;
|
|
import android.content.ClipData;
|
|
import android.content.Intent;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Configuration;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Environment;
|
|
import android.os.ParcelFileDescriptor;
|
|
import android.provider.MediaStore;
|
|
import android.text.TextUtils;
|
|
import android.view.Gravity;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.widget.ListView;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import androidx.appcompat.app.ActionBar;
|
|
import androidx.core.content.FileProvider;
|
|
import androidx.lifecycle.ViewModelProvider;
|
|
import androidx.work.Data;
|
|
import androidx.work.OneTimeWorkRequest;
|
|
import androidx.work.WorkManager;
|
|
|
|
import com.squareup.otto.Subscribe;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
|
|
import javax.inject.Inject;
|
|
|
|
import butterknife.BindView;
|
|
import ch.protonmail.android.R;
|
|
import ch.protonmail.android.adapters.AttachmentListAdapter;
|
|
import ch.protonmail.android.attachments.AttachmentsViewModel;
|
|
import ch.protonmail.android.attachments.AttachmentsViewState;
|
|
import ch.protonmail.android.attachments.ImportAttachmentsWorker;
|
|
import ch.protonmail.android.core.Constants;
|
|
import ch.protonmail.android.core.ProtonMailApplication;
|
|
import ch.protonmail.android.data.local.model.Attachment;
|
|
import ch.protonmail.android.data.local.model.LocalAttachment;
|
|
import ch.protonmail.android.events.DownloadedAttachmentEvent;
|
|
import ch.protonmail.android.events.PostImportAttachmentEvent;
|
|
import ch.protonmail.android.events.PostImportAttachmentFailureEvent;
|
|
import ch.protonmail.android.events.Status;
|
|
import ch.protonmail.android.utils.DateUtil;
|
|
import ch.protonmail.android.utils.DownloadUtils;
|
|
import ch.protonmail.android.utils.Logger;
|
|
import ch.protonmail.android.utils.extensions.TextExtensions;
|
|
import ch.protonmail.android.utils.ui.dialogs.DialogUtils;
|
|
import dagger.hilt.android.AndroidEntryPoint;
|
|
import kotlin.collections.ArraysKt;
|
|
import kotlin.collections.CollectionsKt;
|
|
import timber.log.Timber;
|
|
|
|
@AndroidEntryPoint
|
|
public class AddAttachmentsActivity extends BaseStoragePermissionActivity implements AttachmentListAdapter.IAttachmentListener {
|
|
|
|
private static final String TAG_ADD_ATTACHMENTS_ACTIVITY = "AddAttachmentsActivity";
|
|
public static final String EXTRA_ATTACHMENT_LIST = "EXTRA_ATTACHMENT_LIST";
|
|
public static final String EXTRA_DRAFT_ID = "EXTRA_DRAFT_ID";
|
|
public static final String EXTRA_DRAFT_CREATED = "EXTRA_DRAFT_CREATED";
|
|
private static final String ATTACHMENT_MIME_TYPE = "*/*";
|
|
private static final int REQUEST_CODE_ATTACH_FILE = 1;
|
|
private static final int REQUEST_CODE_TAKE_PHOTO = 2;
|
|
private static final String STATE_PHOTO_PATH = "STATE_PATH_TO_PHOTO";
|
|
|
|
private AttachmentListAdapter mAdapter;
|
|
@BindView(R.id.progress_layout)
|
|
View mProgressLayout;
|
|
@BindView(R.id.processing_attachment_layout)
|
|
View mProcessingAttachmentLayout;
|
|
@BindView(R.id.no_attachments)
|
|
View mNoAttachmentsView;
|
|
@BindView(R.id.num_attachments)
|
|
TextView mNumAttachmentsView;
|
|
@BindView(R.id.attachment_list)
|
|
ListView mListView;
|
|
|
|
@Inject
|
|
WorkManager workManager;
|
|
@Inject
|
|
DownloadUtils downloadUtils;
|
|
|
|
private String mPathToPhoto;
|
|
private String mDraftId;
|
|
private boolean mDraftCreated;
|
|
private List<Uri> mAttachFileWithoutPermission;
|
|
private String mAttachTakePhotoWithoutPermission;
|
|
private boolean openGallery = false;
|
|
private boolean openCamera = false;
|
|
|
|
@Override
|
|
protected int getLayoutId() {
|
|
return R.layout.activity_add_attachments;
|
|
}
|
|
|
|
@Override
|
|
public void onHasPermission(Constants.PermissionType type) {
|
|
if (type == Constants.PermissionType.STORAGE) {
|
|
super.onHasPermission(type);
|
|
mHasStoragePermission = true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPermissionDenied(Constants.PermissionType type) {
|
|
super.onPermissionDenied(type);
|
|
openCamera = false;
|
|
openGallery = false;
|
|
DialogUtils.Companion.showInfoDialog(AddAttachmentsActivity.this, getString(R.string.need_permissions_title),
|
|
getString(R.string.need_storage_permissions_add_attachment_text), unit -> unit);
|
|
}
|
|
|
|
@Override
|
|
public void onPermissionConfirmed(Constants.PermissionType type) {
|
|
super.onPermissionConfirmed(type);
|
|
if (openGallery) {
|
|
openGallery();
|
|
}
|
|
if (openCamera) {
|
|
openCamera();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void storagePermissionGranted() {
|
|
mHasStoragePermission = true;
|
|
if (mAttachFileWithoutPermission != null && mAttachFileWithoutPermission.size() > 0) {
|
|
mProcessingAttachmentLayout.setVisibility(View.VISIBLE);
|
|
|
|
String[] uriStrings = new String[mAttachFileWithoutPermission.size()];
|
|
for (int i = 0; i < mAttachFileWithoutPermission.size(); i++) {
|
|
uriStrings[i] = mAttachFileWithoutPermission.get(i).toString();
|
|
}
|
|
|
|
Data workerData = new Data.Builder()
|
|
.putStringArray(KEY_INPUT_DATA_FILE_URIS_STRING_ARRAY, uriStrings)
|
|
.build();
|
|
|
|
OneTimeWorkRequest importAttachmentsWork = new OneTimeWorkRequest.Builder(ImportAttachmentsWorker.class)
|
|
.setInputData(workerData)
|
|
.build();
|
|
|
|
workManager.enqueue(importAttachmentsWork);
|
|
|
|
mAttachFileWithoutPermission = null;
|
|
}
|
|
if (!TextUtils.isEmpty(mAttachTakePhotoWithoutPermission)) {
|
|
mProcessingAttachmentLayout.setVisibility(View.VISIBLE);
|
|
handleTakePhotoRequest(mAttachTakePhotoWithoutPermission);
|
|
mAttachTakePhotoWithoutPermission = null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected boolean checkForPermissionOnStartup() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
ActionBar actionBar = getSupportActionBar();
|
|
if (actionBar != null) {
|
|
actionBar.setDisplayHomeAsUpEnabled(true);
|
|
actionBar.setTitle(R.string.add_attachment);
|
|
}
|
|
|
|
Intent intent = getIntent();
|
|
ArrayList<LocalAttachment> attachmentList = intent.getParcelableArrayListExtra(EXTRA_ATTACHMENT_LIST);
|
|
if (attachmentList == null) {
|
|
attachmentList = new ArrayList<>();
|
|
}
|
|
mDraftId = intent.getStringExtra(EXTRA_DRAFT_ID);
|
|
mDraftCreated = intent.getBooleanExtra(EXTRA_DRAFT_CREATED, true);
|
|
int attachmentsCount = attachmentList.size();
|
|
int totalEmbeddedImages = countEmbeddedImages(attachmentList);
|
|
updateAttachmentsCount(attachmentsCount, totalEmbeddedImages);
|
|
if (mDraftCreated) {
|
|
mProgressLayout.setVisibility(View.GONE);
|
|
} else {
|
|
mProgressLayout.setVisibility(View.VISIBLE);
|
|
}
|
|
mAdapter = new AttachmentListAdapter(this, attachmentList, totalEmbeddedImages,
|
|
workManager);
|
|
mListView.setAdapter(mAdapter);
|
|
|
|
AttachmentsViewModel viewModel = new ViewModelProvider(this).get(AttachmentsViewModel.class);
|
|
viewModel.init();
|
|
|
|
viewModel.getViewState().observe(this, this::viewStateChanged);
|
|
}
|
|
|
|
@Override
|
|
protected void onStart() {
|
|
super.onStart();
|
|
ProtonMailApplication.getApplication().getBus().register(this);
|
|
}
|
|
|
|
@Override
|
|
protected void onStop() {
|
|
super.onStop();
|
|
ProtonMailApplication.getApplication().getBus().unregister(this);
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu) {
|
|
getMenuInflater().inflate(R.menu.menu_attachments, menu);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onPrepareOptionsMenu(Menu menu) {
|
|
menu.findItem(R.id.take_photo).setVisible(getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA));
|
|
menu.findItem(R.id.attach_file).setVisible(mDraftCreated);
|
|
menu.findItem(R.id.take_photo).setVisible(mDraftCreated);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onBackPressed() {
|
|
Intent intent = new Intent();
|
|
intent.putExtra(EXTRA_DRAFT_ID, mDraftId);
|
|
ArrayList<LocalAttachment> currentAttachments = mAdapter.getData();
|
|
intent.putParcelableArrayListExtra(EXTRA_ATTACHMENT_LIST, currentAttachments);
|
|
setResult(Activity.RESULT_OK, intent);
|
|
finish();
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
case android.R.id.home:
|
|
onBackPressed();
|
|
return true;
|
|
case R.id.attach_file: {
|
|
openGallery = true;
|
|
if (mHasStoragePermission != null && mHasStoragePermission) {
|
|
return openGallery();
|
|
} else {
|
|
storagePermissionHelper.checkPermission();
|
|
return false;
|
|
}
|
|
}
|
|
case R.id.take_photo: {
|
|
openCamera = true;
|
|
if (mHasStoragePermission != null && mHasStoragePermission) {
|
|
return openCamera();
|
|
} else {
|
|
storagePermissionHelper.checkPermission();
|
|
return false;
|
|
}
|
|
}
|
|
default:
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
}
|
|
|
|
private boolean isAttachmentsSizeAllowed(long newAttachmentSie) {
|
|
if (mAdapter == null) return false;
|
|
|
|
long currentAttachmentsSize =
|
|
CollectionsKt.sumOfLong(CollectionsKt.map(mAdapter.getData(), LocalAttachment::getSize));
|
|
|
|
return currentAttachmentsSize + newAttachmentSie < Constants.MAX_ATTACHMENT_FILE_SIZE_IN_BYTES;
|
|
}
|
|
|
|
private boolean isAttachmentsCountAllowed() {
|
|
return mAdapter != null && mAdapter.getCount() < Constants.MAX_ATTACHMENTS;
|
|
}
|
|
|
|
@Subscribe
|
|
public void onPostImportAttachmentEvent(PostImportAttachmentEvent event) {
|
|
mProcessingAttachmentLayout.setVisibility(View.GONE);
|
|
mNoAttachmentsView.setVisibility(View.GONE);
|
|
LocalAttachment newAttachment = new LocalAttachment(Uri.parse(event.uri), event.displayName, event.size, event.mimeType);
|
|
ArrayList<LocalAttachment> currentAttachments = mAdapter.getData();
|
|
boolean alreadyExists = false;
|
|
for (LocalAttachment localAttachment : currentAttachments) {
|
|
String localAttachmentDisplayName = localAttachment.getDisplayName();
|
|
boolean isEmpty = TextUtils.isEmpty(localAttachmentDisplayName);
|
|
if (!isEmpty && localAttachmentDisplayName.equals(newAttachment.getDisplayName())) {
|
|
alreadyExists = true;
|
|
}
|
|
}
|
|
if (alreadyExists) {
|
|
TextExtensions.showToast(AddAttachmentsActivity.this, R.string.attachment_exists, Toast.LENGTH_SHORT);
|
|
return;
|
|
}
|
|
currentAttachments.add(newAttachment);
|
|
int totalEmbeddedImages = countEmbeddedImages(currentAttachments);
|
|
mAdapter.updateData(new ArrayList<>(currentAttachments), totalEmbeddedImages);
|
|
int attachments = currentAttachments.size();
|
|
updateAttachmentsCount(attachments, totalEmbeddedImages);
|
|
}
|
|
|
|
@Subscribe
|
|
public void onPostImportAttachmentFailureEvent(PostImportAttachmentFailureEvent event) {
|
|
mProcessingAttachmentLayout.setVisibility(View.GONE);
|
|
TextExtensions.showToast(this, R.string.problem_selecting_file);
|
|
}
|
|
|
|
@Override
|
|
public void onConfigurationChanged(Configuration newConfig) {
|
|
super.onConfigurationChanged(newConfig);
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(int requestCode, int resultCode, Intent data) {
|
|
if (resultCode != RESULT_OK) {
|
|
super.onActivityResult(requestCode, resultCode, data);
|
|
return;
|
|
}
|
|
|
|
if (mHasStoragePermission == null || !mHasStoragePermission) {
|
|
|
|
if (requestCode == REQUEST_CODE_ATTACH_FILE) {
|
|
mAttachFileWithoutPermission = new ArrayList<>();
|
|
ClipData clipData = data.getClipData();
|
|
if (clipData != null) {
|
|
for (int i = 0; i < clipData.getItemCount(); i++) {
|
|
ClipData.Item item = clipData.getItemAt(i);
|
|
mAttachFileWithoutPermission.add(item.getUri());
|
|
}
|
|
} else {
|
|
mAttachFileWithoutPermission.add(data.getData());
|
|
}
|
|
|
|
} else if (requestCode == REQUEST_CODE_TAKE_PHOTO) {
|
|
mAttachTakePhotoWithoutPermission = mPathToPhoto;
|
|
}
|
|
|
|
storagePermissionHelper.checkPermission();
|
|
return;
|
|
}
|
|
|
|
if (requestCode == REQUEST_CODE_ATTACH_FILE) {
|
|
handleAttachFileRequest(data.getData(), data.getClipData());
|
|
|
|
} else if (requestCode == REQUEST_CODE_TAKE_PHOTO) {
|
|
handleTakePhotoRequest(mPathToPhoto);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onSaveInstanceState(Bundle outState) {
|
|
outState.putString(STATE_PHOTO_PATH, mPathToPhoto);
|
|
super.onSaveInstanceState(outState);
|
|
}
|
|
|
|
@Override
|
|
protected void onRestoreInstanceState(Bundle savedInstanceState) {
|
|
super.onRestoreInstanceState(savedInstanceState);
|
|
mPathToPhoto = savedInstanceState.getString(STATE_PHOTO_PATH);
|
|
}
|
|
|
|
@Subscribe
|
|
public void onDownloadAttachmentEvent(DownloadedAttachmentEvent event) {
|
|
//once attachment has been downloaded
|
|
if (event.getStatus().equals(Status.SUCCESS)) {
|
|
downloadUtils.viewAttachment(event.getFilename(), event.getAttachmentUri());
|
|
TextExtensions.showToast(this, String.format(getString(R.string.attachment_download_success), event.getFilename()), Toast.LENGTH_SHORT);
|
|
} else {
|
|
TextExtensions.showToast(this, String.format(getString(R.string.attachment_download_failed), event.getFilename()), Toast.LENGTH_SHORT);
|
|
}
|
|
}
|
|
|
|
private void viewStateChanged(AttachmentsViewState viewState) {
|
|
if (viewState instanceof AttachmentsViewState.MissingConnectivity) {
|
|
onMessageReady();
|
|
}
|
|
|
|
if (viewState instanceof AttachmentsViewState.UpdateAttachments) {
|
|
onMessageReady();
|
|
updateDisplayedAttachments(
|
|
((AttachmentsViewState.UpdateAttachments) viewState).getAttachments()
|
|
);
|
|
}
|
|
}
|
|
|
|
private void onMessageReady() {
|
|
mDraftCreated = true;
|
|
mProgressLayout.setVisibility(View.GONE);
|
|
invalidateOptionsMenu();
|
|
}
|
|
|
|
private void updateDisplayedAttachments(List<Attachment> attachments) {
|
|
List<LocalAttachment> localAttachments = new ArrayList<>(
|
|
LocalAttachment.Companion.createLocalAttachmentList(attachments)
|
|
);
|
|
int totalEmbeddedImages = countEmbeddedImages(localAttachments);
|
|
mAdapter.updateData(new ArrayList(localAttachments), totalEmbeddedImages);
|
|
}
|
|
|
|
|
|
private void handleAttachFileRequest(Uri uri, ClipData clipData) {
|
|
String[] uris = null;
|
|
|
|
String uriString = uri != null ? uri.toString() : null;
|
|
if (uriString != null) {
|
|
uris = new String[]{uriString};
|
|
}
|
|
|
|
if (clipData != null) {
|
|
uris = new String[clipData.getItemCount()];
|
|
for (int i = 0; i < clipData.getItemCount(); i++) {
|
|
uris[i] = clipData.getItemAt(i).getUri().toString();
|
|
}
|
|
}
|
|
|
|
if (uris != null) {
|
|
|
|
// region Check whether the size of the attachments is within bounds
|
|
final AtomicLong incrementalSize = new AtomicLong(0);
|
|
List<String> sizeComplaintUrisList = ArraysKt.filter(uris, fileUriString -> {
|
|
Uri fileUri = Uri.parse(fileUriString);
|
|
|
|
try {
|
|
ParcelFileDescriptor fileDescriptor = getContentResolver().openFileDescriptor(fileUri, "r");
|
|
if (fileDescriptor == null) {
|
|
return false;
|
|
}
|
|
final long fileSize = fileDescriptor.getStatSize();
|
|
return isAttachmentsSizeAllowed(incrementalSize.addAndGet(fileSize));
|
|
|
|
} catch (FileNotFoundException e) {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
if (sizeComplaintUrisList.size() < uris.length) {
|
|
TextExtensions.showToast(this, R.string.max_attachments_size_reached);
|
|
}
|
|
// endregion
|
|
|
|
if (sizeComplaintUrisList.size() > 0) {
|
|
mProcessingAttachmentLayout.setVisibility(View.VISIBLE);
|
|
|
|
String[] sizeComplaintUris = new String[sizeComplaintUrisList.size()];
|
|
sizeComplaintUrisList.toArray(sizeComplaintUris);
|
|
Data workerData = new Data.Builder()
|
|
.putStringArray(KEY_INPUT_DATA_FILE_URIS_STRING_ARRAY, sizeComplaintUris)
|
|
.build();
|
|
|
|
OneTimeWorkRequest importAttachmentsWork = new OneTimeWorkRequest.Builder(ImportAttachmentsWorker.class)
|
|
.setInputData(workerData)
|
|
.build();
|
|
|
|
workManager.enqueue(importAttachmentsWork);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void handleTakePhotoRequest(String path) {
|
|
if (!TextUtils.isEmpty(path)) {
|
|
|
|
File file = new File(path);
|
|
|
|
// Check whether the size of the attachment is within bounds
|
|
if (!isAttachmentsSizeAllowed(file.length())) {
|
|
TextExtensions.showToast(this, R.string.max_attachments_size_reached);
|
|
return;
|
|
}
|
|
|
|
mProcessingAttachmentLayout.setVisibility(View.VISIBLE);
|
|
|
|
Uri uri = Uri.fromFile(file);
|
|
Data data = new Data.Builder()
|
|
.putStringArray(KEY_INPUT_DATA_FILE_URIS_STRING_ARRAY, new String[]{uri.toString()})
|
|
.putBoolean(KEY_INPUT_DATA_DELETE_ORIGINAL_FILE_BOOLEAN, true)
|
|
.build();
|
|
|
|
OneTimeWorkRequest importAttachmentsWork = new OneTimeWorkRequest.Builder(ImportAttachmentsWorker.class)
|
|
.setInputData(data)
|
|
.build();
|
|
|
|
workManager.enqueue(importAttachmentsWork);
|
|
|
|
workManager.getWorkInfoByIdLiveData(importAttachmentsWork.getId()).observe(this, workInfo -> {
|
|
if (workInfo != null) {
|
|
Timber.d("ImportAttachmentsWorker workInfo = " + workInfo.getState());
|
|
}
|
|
});
|
|
|
|
} else {
|
|
TextExtensions.showToast(this, R.string.attaching_photo_failed, Toast.LENGTH_LONG, Gravity.CENTER);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAttachmentDeleted(int remainingAttachments, int embeddedImagesCount) {
|
|
updateAttachmentsCount(remainingAttachments, embeddedImagesCount);
|
|
}
|
|
|
|
@Override
|
|
public void askStoragePermission() {
|
|
storagePermissionHelper.checkPermission();
|
|
}
|
|
|
|
private void updateAttachmentsCount(int totalAttachmentsCount, int totalEmbeddedImagesCount) {
|
|
if (totalAttachmentsCount == 0 && totalEmbeddedImagesCount == 0) {
|
|
mNoAttachmentsView.postDelayed(() -> mNoAttachmentsView.setVisibility(View.VISIBLE), 350);
|
|
mNumAttachmentsView.setVisibility(View.GONE);
|
|
} else {
|
|
int normalAttachments = totalAttachmentsCount - totalEmbeddedImagesCount;
|
|
if (normalAttachments > 0) {
|
|
mNumAttachmentsView.setText(getResources().getQuantityString(R.plurals.attachments, normalAttachments, normalAttachments));
|
|
mNumAttachmentsView.setVisibility(View.VISIBLE);
|
|
} else {
|
|
mNumAttachmentsView.setText(getString(R.string.no_attachments));
|
|
mNumAttachmentsView.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODO extract logic to separate class as it is not dependant on activity
|
|
private int countEmbeddedImages(List<LocalAttachment> attachments) {
|
|
int embeddedImages = 0;
|
|
for (LocalAttachment localAttachment : attachments) {
|
|
if (localAttachment.isEmbeddedImage()) {
|
|
embeddedImages++;
|
|
}
|
|
}
|
|
return embeddedImages;
|
|
}
|
|
|
|
private boolean openGallery() {
|
|
if (!isAttachmentsCountAllowed()) {
|
|
TextExtensions.showToast(this, R.string.max_attachments_reached);
|
|
return true;
|
|
}
|
|
Intent target = new Intent(Intent.ACTION_GET_CONTENT);
|
|
target.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
|
|
target.addCategory(Intent.CATEGORY_OPENABLE);
|
|
target.setType(ATTACHMENT_MIME_TYPE);
|
|
Intent intent = Intent.createChooser(target, getString(R.string.select_file));
|
|
if (intent.resolveActivity(getPackageManager()) != null) {
|
|
startActivityForResult(intent, REQUEST_CODE_ATTACH_FILE);
|
|
} else {
|
|
TextExtensions.showToast(this, R.string.no_application_found);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private boolean openCamera() {
|
|
if (!isAttachmentsCountAllowed()) {
|
|
TextExtensions.showToast(this, R.string.max_attachments_reached);
|
|
return true;
|
|
}
|
|
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
|
|
if (intent.resolveActivity(getPackageManager()) != null) {
|
|
String timestamp = DateUtil.generateTimestamp();
|
|
timestamp = timestamp.replace("-", "");
|
|
timestamp = timestamp.replaceAll("[^A-Za-z0-9]", "");
|
|
File directory = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
|
|
try {
|
|
if (timestamp.length() < 3) {
|
|
Random random = new Random();
|
|
int number = random.nextInt(99999) + 100;
|
|
timestamp = timestamp + String.valueOf(number);
|
|
}
|
|
File file = File.createTempFile(timestamp, ".jpg", directory);
|
|
intent.putExtra(MediaStore.EXTRA_OUTPUT, FileProvider.getUriForFile(AddAttachmentsActivity.this, getApplicationContext().getPackageName() + ".provider", file));
|
|
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
|
|
mPathToPhoto = file.getAbsolutePath();
|
|
startActivityForResult(intent, REQUEST_CODE_TAKE_PHOTO);
|
|
} catch (IOException ioe) {
|
|
Logger.doLogException(TAG_ADD_ATTACHMENTS_ACTIVITY,
|
|
"Exception creating temporary file for photo", ioe);
|
|
TextExtensions.showToast(this, R.string.problem_taking_photo);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|