2018-08-02 13:33:06 +00:00
|
|
|
package eu.faircode.email;
|
|
|
|
|
|
|
|
/*
|
2018-08-14 05:53:24 +00:00
|
|
|
This file is part of FairEmail.
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-08-14 05:53:24 +00:00
|
|
|
FairEmail is free software: you can redistribute it and/or modify
|
2018-08-02 13:33:06 +00:00
|
|
|
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.
|
|
|
|
|
2018-10-29 10:46:49 +00:00
|
|
|
FairEmail is distributed in the hope that it will be useful,
|
2018-08-02 13:33:06 +00:00
|
|
|
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
|
2018-10-29 10:46:49 +00:00
|
|
|
along with FairEmail. If not, see <http://www.gnu.org/licenses/>.
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2023-01-01 07:52:55 +00:00
|
|
|
Copyright 2018-2023 by Marcel Bokhorst (M66B)
|
2018-08-02 13:33:06 +00:00
|
|
|
*/
|
|
|
|
|
2021-08-18 17:37:10 +00:00
|
|
|
import static androidx.room.ForeignKey.CASCADE;
|
|
|
|
|
2018-08-21 14:25:42 +00:00
|
|
|
import android.content.Context;
|
2022-02-01 21:38:47 +00:00
|
|
|
import android.content.SharedPreferences;
|
2023-01-05 14:21:22 +00:00
|
|
|
import android.net.Uri;
|
2019-03-14 09:12:19 +00:00
|
|
|
import android.text.TextUtils;
|
2018-08-21 14:25:42 +00:00
|
|
|
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.annotation.NonNull;
|
2023-01-05 14:21:22 +00:00
|
|
|
import androidx.core.content.FileProvider;
|
2022-02-01 21:38:47 +00:00
|
|
|
import androidx.preference.PreferenceManager;
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.room.Entity;
|
|
|
|
import androidx.room.ForeignKey;
|
2023-06-26 09:35:26 +00:00
|
|
|
import androidx.room.Ignore;
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.room.Index;
|
|
|
|
import androidx.room.PrimaryKey;
|
|
|
|
|
2022-11-08 12:33:26 +00:00
|
|
|
import java.io.BufferedInputStream;
|
|
|
|
import java.io.BufferedOutputStream;
|
2018-08-21 14:25:42 +00:00
|
|
|
import java.io.File;
|
2022-11-08 12:33:26 +00:00
|
|
|
import java.io.FileInputStream;
|
|
|
|
import java.io.FileOutputStream;
|
2019-01-22 18:02:30 +00:00
|
|
|
import java.io.IOException;
|
2022-11-08 12:33:26 +00:00
|
|
|
import java.io.InputStream;
|
2021-12-08 18:10:42 +00:00
|
|
|
import java.util.ArrayList;
|
2019-01-22 18:02:30 +00:00
|
|
|
import java.util.List;
|
2020-07-25 10:53:55 +00:00
|
|
|
import java.util.Locale;
|
2019-02-26 10:05:21 +00:00
|
|
|
import java.util.Objects;
|
2022-11-08 15:02:54 +00:00
|
|
|
import java.util.zip.Deflater;
|
2022-11-08 12:33:26 +00:00
|
|
|
import java.util.zip.ZipEntry;
|
|
|
|
import java.util.zip.ZipOutputStream;
|
2018-08-21 14:25:42 +00:00
|
|
|
|
2020-04-15 06:42:49 +00:00
|
|
|
import javax.mail.Part;
|
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
@Entity(
|
|
|
|
tableName = EntityAttachment.TABLE_NAME,
|
|
|
|
foreignKeys = {
|
2018-08-08 06:55:47 +00:00
|
|
|
@ForeignKey(childColumns = "message", entity = EntityMessage.class, parentColumns = "id", onDelete = CASCADE)
|
2018-08-02 13:33:06 +00:00
|
|
|
},
|
|
|
|
indices = {
|
2018-08-03 12:07:51 +00:00
|
|
|
@Index(value = {"message"}),
|
2020-08-07 13:23:07 +00:00
|
|
|
@Index(value = {"message", "sequence", "subsequence"}, unique = true),
|
2019-05-08 08:32:37 +00:00
|
|
|
@Index(value = {"message", "cid"})
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
|
|
|
)
|
|
|
|
public class EntityAttachment {
|
|
|
|
static final String TABLE_NAME = "attachment";
|
|
|
|
|
2019-01-05 14:09:47 +00:00
|
|
|
static final Integer PGP_MESSAGE = 1;
|
|
|
|
static final Integer PGP_SIGNATURE = 2;
|
2019-06-30 06:56:33 +00:00
|
|
|
static final Integer PGP_KEY = 3;
|
2019-11-27 09:40:43 +00:00
|
|
|
static final Integer PGP_CONTENT = 4;
|
2019-12-02 07:35:09 +00:00
|
|
|
static final Integer SMIME_MESSAGE = 5;
|
|
|
|
static final Integer SMIME_SIGNATURE = 6;
|
2020-01-10 18:06:54 +00:00
|
|
|
static final Integer SMIME_SIGNED_DATA = 7;
|
2019-12-02 07:35:09 +00:00
|
|
|
static final Integer SMIME_CONTENT = 8;
|
2019-01-05 14:09:47 +00:00
|
|
|
|
2023-03-25 14:46:56 +00:00
|
|
|
static final String VCARD_PREFIX = BuildConfig.APPLICATION_ID + ".vcard.";
|
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
@PrimaryKey(autoGenerate = true)
|
|
|
|
public Long id;
|
2023-06-21 10:23:21 +00:00
|
|
|
public String section;
|
2018-08-02 13:33:06 +00:00
|
|
|
@NonNull
|
|
|
|
public Long message;
|
|
|
|
@NonNull
|
2018-08-03 12:07:51 +00:00
|
|
|
public Integer sequence;
|
2020-08-07 13:23:07 +00:00
|
|
|
public Integer subsequence; // embedded messages
|
2018-08-02 13:33:06 +00:00
|
|
|
public String name;
|
2018-08-03 12:07:51 +00:00
|
|
|
@NonNull
|
|
|
|
public String type;
|
2019-01-06 11:00:08 +00:00
|
|
|
public String disposition;
|
2018-09-13 17:03:28 +00:00
|
|
|
public String cid; // Content-ID
|
2022-02-12 19:39:49 +00:00
|
|
|
public Boolean related; // inline
|
2019-01-05 14:09:47 +00:00
|
|
|
public Integer encryption;
|
2019-01-08 09:00:15 +00:00
|
|
|
public Long size;
|
2018-08-04 10:32:34 +00:00
|
|
|
public Integer progress;
|
2018-08-19 06:53:56 +00:00
|
|
|
@NonNull
|
|
|
|
public Boolean available = false;
|
2022-02-15 12:57:55 +00:00
|
|
|
public String media_uri;
|
2019-01-16 18:27:03 +00:00
|
|
|
public String error;
|
2018-08-03 19:12:19 +00:00
|
|
|
|
2023-06-26 09:35:26 +00:00
|
|
|
@Ignore
|
|
|
|
public boolean selected = true;
|
|
|
|
|
2020-04-15 06:42:49 +00:00
|
|
|
// Gmail sends inline images as attachments with a name and cid
|
|
|
|
|
2019-01-06 11:00:08 +00:00
|
|
|
boolean isInline() {
|
2022-02-12 19:39:49 +00:00
|
|
|
return (Part.INLINE.equals(disposition) ||
|
|
|
|
(!Boolean.FALSE.equals(related) && cid != null));
|
2020-04-15 06:42:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
boolean isAttachment() {
|
|
|
|
return (Part.ATTACHMENT.equals(disposition) || !TextUtils.isEmpty(name));
|
2019-01-06 11:00:08 +00:00
|
|
|
}
|
2019-05-06 05:36:44 +00:00
|
|
|
|
|
|
|
boolean isImage() {
|
2021-08-18 17:37:10 +00:00
|
|
|
return ImageHelper.isImage(getMimeType());
|
2019-05-06 05:36:44 +00:00
|
|
|
}
|
2019-01-06 11:00:08 +00:00
|
|
|
|
2022-03-11 11:20:39 +00:00
|
|
|
boolean isCompressed() {
|
|
|
|
if ("application/zip".equals(type))
|
|
|
|
return true;
|
|
|
|
if ("application/gzip".equals(type) && !BuildConfig.PLAY_STORE_RELEASE)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
String extension = Helper.getExtension(name);
|
|
|
|
if ("zip".equals(extension))
|
|
|
|
return true;
|
|
|
|
if ("gz".equals(extension) && !BuildConfig.PLAY_STORE_RELEASE)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean isGzip() {
|
|
|
|
if (BuildConfig.PLAY_STORE_RELEASE)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ("application/gzip".equals(type))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
String extension = Helper.getExtension(name);
|
|
|
|
if ("gz".equals(extension))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean isTarGzip() {
|
|
|
|
return (name != null && name.endsWith(".tar.gz"));
|
|
|
|
}
|
|
|
|
|
2020-04-15 06:52:01 +00:00
|
|
|
boolean isEncryption() {
|
2021-04-24 14:38:55 +00:00
|
|
|
if ("application/pkcs7-mime".equals(type))
|
|
|
|
return true;
|
|
|
|
if ("application/x-pkcs7-mime".equals(type))
|
|
|
|
return true;
|
|
|
|
if ("application/pkcs7-signature".equals(type))
|
|
|
|
return true;
|
|
|
|
if ("application/x-pkcs7-signature".equals(type))
|
|
|
|
return true;
|
2020-04-15 06:52:01 +00:00
|
|
|
return (encryption != null);
|
|
|
|
}
|
|
|
|
|
2023-01-05 14:21:22 +00:00
|
|
|
Uri getUri(Context context) {
|
|
|
|
File file = getFile(context);
|
|
|
|
if (TextUtils.isEmpty(name))
|
|
|
|
return FileProvider.getUriForFile(context, BuildConfig.APPLICATION_ID, file);
|
|
|
|
else
|
|
|
|
return FileProvider.getUriForFile(context, BuildConfig.APPLICATION_ID, file, name);
|
|
|
|
}
|
|
|
|
|
2019-03-14 07:18:42 +00:00
|
|
|
File getFile(Context context) {
|
2019-05-12 13:29:18 +00:00
|
|
|
return getFile(context, id, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static File getFile(Context context, long id, String name) {
|
2022-10-06 12:43:44 +00:00
|
|
|
File dir = Helper.ensureExists(new File(getRoot(context), "attachments"));
|
2019-03-14 09:12:19 +00:00
|
|
|
String filename = Long.toString(id);
|
|
|
|
if (!TextUtils.isEmpty(name))
|
|
|
|
filename += "." + Helper.sanitizeFilename(name);
|
2019-09-06 14:08:51 +00:00
|
|
|
if (filename.length() > 127)
|
|
|
|
filename = filename.substring(0, 127);
|
2019-03-14 09:12:19 +00:00
|
|
|
return new File(dir, filename);
|
2018-08-21 14:25:42 +00:00
|
|
|
}
|
|
|
|
|
2022-10-06 12:07:18 +00:00
|
|
|
static File getRoot(Context context) {
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
boolean external_storage = prefs.getBoolean("external_storage", false);
|
|
|
|
|
|
|
|
File root = (external_storage
|
2022-11-03 15:57:53 +00:00
|
|
|
? Helper.getExternalFilesDir(context)
|
2022-10-06 12:07:18 +00:00
|
|
|
: context.getFilesDir());
|
|
|
|
return root;
|
|
|
|
}
|
|
|
|
|
2019-03-14 07:18:42 +00:00
|
|
|
static void copy(Context context, long oldid, long newid) {
|
|
|
|
DB db = DB.getInstance(context);
|
2019-07-24 08:43:32 +00:00
|
|
|
|
2019-01-22 18:02:30 +00:00
|
|
|
List<EntityAttachment> attachments = db.attachment().getAttachments(oldid);
|
|
|
|
for (EntityAttachment attachment : attachments) {
|
2019-03-14 07:18:42 +00:00
|
|
|
File source = attachment.getFile(context);
|
|
|
|
|
2019-01-22 18:02:30 +00:00
|
|
|
attachment.id = null;
|
|
|
|
attachment.message = newid;
|
|
|
|
attachment.progress = null;
|
|
|
|
attachment.id = db.attachment().insertAttachment(attachment);
|
2019-03-14 07:18:42 +00:00
|
|
|
|
|
|
|
if (attachment.available) {
|
|
|
|
File target = attachment.getFile(context);
|
2019-01-22 18:02:30 +00:00
|
|
|
try {
|
2019-03-14 07:18:42 +00:00
|
|
|
Helper.copy(source, target);
|
2019-01-22 18:02:30 +00:00
|
|
|
} catch (IOException ex) {
|
|
|
|
Log.e(ex);
|
2019-12-06 07:50:46 +00:00
|
|
|
db.attachment().setError(attachment.id, Log.formatThrowable(ex, false));
|
2019-01-22 18:02:30 +00:00
|
|
|
}
|
2019-03-14 07:18:42 +00:00
|
|
|
}
|
2019-01-22 18:02:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-20 18:31:40 +00:00
|
|
|
String getMimeType() {
|
|
|
|
// Try to guess a better content type
|
|
|
|
// For example, sometimes PDF files are sent as application/octet-stream
|
2021-02-05 12:01:05 +00:00
|
|
|
|
2019-12-10 20:16:08 +00:00
|
|
|
// https://android.googlesource.com/platform/libcore/+/refs/tags/android-9.0.0_r49/luni/src/main/java/libcore/net/MimeUtils.java
|
2021-04-05 05:52:04 +00:00
|
|
|
// https://docs.microsoft.com/en-us/archive/blogs/vsofficedeveloper/office-2007-file-format-mime-types-for-http-content-streaming-2
|
2019-12-10 20:16:08 +00:00
|
|
|
|
2019-10-20 18:31:40 +00:00
|
|
|
if (encryption != null)
|
|
|
|
return type;
|
|
|
|
|
2022-07-10 20:29:06 +00:00
|
|
|
if ("audio/mid".equals(type))
|
|
|
|
return "audio/midi";
|
|
|
|
|
2023-04-24 19:40:02 +00:00
|
|
|
if ("audio-x/wav".equals(type))
|
|
|
|
return "audio/wav";
|
|
|
|
|
2022-07-10 20:29:06 +00:00
|
|
|
// https://www.rfc-editor.org/rfc/rfc3555.txt
|
|
|
|
if ("image/jpg".equals(type) || "video/jpeg".equals(type))
|
|
|
|
return "image/jpeg";
|
|
|
|
|
|
|
|
if (!TextUtils.isEmpty(type) &&
|
|
|
|
(type.endsWith("/pdf") || type.endsWith("/x-pdf")))
|
|
|
|
return "application/pdf";
|
|
|
|
|
2023-04-14 05:36:15 +00:00
|
|
|
if ("text/v-calendar".equals(type) ||
|
|
|
|
"text/x-vcalendar".equals(type))
|
|
|
|
return "text/calendar";
|
|
|
|
|
2019-10-20 18:31:40 +00:00
|
|
|
String extension = Helper.getExtension(name);
|
|
|
|
if (extension == null)
|
|
|
|
return type;
|
|
|
|
|
2021-02-05 12:01:05 +00:00
|
|
|
String gtype = Helper.guessMimeType(name);
|
|
|
|
if (!TextUtils.isEmpty(type) && !type.equals(gtype))
|
|
|
|
Log.w("Mime type=" + type + " extension=" + extension + " guessed=" + gtype);
|
|
|
|
|
2020-07-25 10:53:55 +00:00
|
|
|
extension = extension.toLowerCase(Locale.ROOT);
|
|
|
|
|
2020-07-14 13:07:09 +00:00
|
|
|
// Fix types
|
2021-10-21 12:40:19 +00:00
|
|
|
if ("csv".equals(extension))
|
|
|
|
return "text/csv";
|
|
|
|
|
2022-01-19 07:04:00 +00:00
|
|
|
if ("gpx".equals(extension))
|
|
|
|
return "application/gpx+xml";
|
|
|
|
|
|
|
|
// Adobe
|
|
|
|
|
2021-08-19 08:08:27 +00:00
|
|
|
if ("dxf".equals(extension))
|
|
|
|
return "application/dxf";
|
|
|
|
|
2022-01-19 07:04:00 +00:00
|
|
|
if ("pdf".equals(extension))
|
|
|
|
return "application/pdf";
|
|
|
|
|
|
|
|
// Microsoft
|
2020-05-23 06:58:25 +00:00
|
|
|
|
2021-04-05 05:52:04 +00:00
|
|
|
if ("doc".equals(extension))
|
|
|
|
return "application/msword";
|
|
|
|
|
|
|
|
if ("docx".equals(extension))
|
|
|
|
return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
|
|
|
|
|
|
|
|
if ("xls".equals(extension))
|
|
|
|
return "application/vnd.ms-excel";
|
|
|
|
|
|
|
|
if ("xlsx".equals(extension))
|
|
|
|
return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
|
|
|
|
|
|
|
|
if ("ppt".equals(extension))
|
|
|
|
return "application/vnd.ms-powerpoint";
|
|
|
|
|
2022-07-14 05:28:02 +00:00
|
|
|
if ("application/vnd.ms-pps".equals(type))
|
|
|
|
return "application/vnd.ms-powerpoint";
|
|
|
|
|
2021-04-05 05:52:04 +00:00
|
|
|
if ("pptx".equals(extension))
|
|
|
|
return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
|
|
|
|
|
2023-03-20 13:56:58 +00:00
|
|
|
if ("ppsx".equals(extension))
|
|
|
|
return "application/vnd.openxmlformats-officedocument.presentationml.slideshow";
|
|
|
|
|
2022-01-19 07:04:00 +00:00
|
|
|
// OpenOffice
|
|
|
|
|
|
|
|
if ("odt".equals(extension))
|
|
|
|
return "application/vnd.oasis.opendocument.text";
|
|
|
|
|
|
|
|
if ("ods".equals(extension))
|
|
|
|
return "application/vnd.oasis.opendocument.spreadsheet";
|
|
|
|
|
|
|
|
if ("odp".equals(extension))
|
|
|
|
return "application/vnd.oasis.opendocument.presentation";
|
|
|
|
|
2022-11-23 17:48:21 +00:00
|
|
|
// Audio
|
|
|
|
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Configuring_servers_for_Ogg_media
|
|
|
|
|
|
|
|
if ("oga".equals(extension))
|
|
|
|
return "audio/ogg";
|
|
|
|
|
|
|
|
if ("ogv".equals(extension))
|
|
|
|
return "video/ogg";
|
|
|
|
|
|
|
|
if ("ogg".equals(extension))
|
|
|
|
return "application/ogg";
|
|
|
|
|
2022-04-19 15:10:59 +00:00
|
|
|
// Images
|
|
|
|
|
|
|
|
if ("avif".equals(extension))
|
|
|
|
return "image/avif";
|
|
|
|
|
|
|
|
if ("bmp".equals(extension))
|
|
|
|
return "image/bmp";
|
|
|
|
|
|
|
|
if ("heic".equals(extension))
|
|
|
|
return "image/heic";
|
|
|
|
|
|
|
|
if ("heif".equals(extension))
|
|
|
|
return "image/heif";
|
|
|
|
|
|
|
|
if ("gif".equals(extension))
|
|
|
|
return "image/gif";
|
|
|
|
|
|
|
|
if ("jpg".equals(extension) || "jpeg".equals(extension))
|
|
|
|
return "image/jpeg";
|
|
|
|
|
|
|
|
if ("png".equals(extension))
|
|
|
|
return "image/png";
|
|
|
|
|
|
|
|
if ("svg".equals(extension))
|
|
|
|
return "image/svg+xml";
|
|
|
|
|
|
|
|
if ("webp".equals(extension))
|
|
|
|
return "image/webp";
|
|
|
|
|
2022-01-19 07:04:00 +00:00
|
|
|
// Other
|
2020-08-07 14:26:19 +00:00
|
|
|
|
2022-01-18 14:02:30 +00:00
|
|
|
if ("zip".equals(extension) ||
|
|
|
|
"application/x-zip-compressed".equals(type))
|
|
|
|
return "application/zip"; //
|
|
|
|
|
2023-05-08 05:53:15 +00:00
|
|
|
if ("ics".equals(extension) || "vcs".equals(extension))
|
2020-01-26 17:11:53 +00:00
|
|
|
return "text/calendar";
|
|
|
|
|
|
|
|
if ("text/plain".equals(type) && "ovpn".equals(extension))
|
2019-11-25 08:40:36 +00:00
|
|
|
return "application/x-openvpn-profile";
|
2019-11-17 10:11:26 +00:00
|
|
|
|
2020-07-14 13:07:09 +00:00
|
|
|
// Guess types
|
|
|
|
if (gtype != null) {
|
|
|
|
if (TextUtils.isEmpty(type) ||
|
|
|
|
"*/*".equals(type) ||
|
|
|
|
type.startsWith("unknown/") ||
|
|
|
|
type.endsWith("/unknown") ||
|
2021-02-05 10:26:28 +00:00
|
|
|
"application/base64".equals(type) ||
|
2020-07-14 13:07:09 +00:00
|
|
|
"application/octet-stream".equals(type) ||
|
2022-01-14 06:40:18 +00:00
|
|
|
"application/x-unknown-content-type".equals(type) ||
|
2020-07-14 13:07:09 +00:00
|
|
|
"application/zip".equals(type))
|
|
|
|
return gtype;
|
2019-10-20 18:31:40 +00:00
|
|
|
|
2020-07-14 13:07:09 +00:00
|
|
|
// Some servers erroneously remove dots from mime types
|
|
|
|
if (gtype.replace(".", "").equals(type))
|
|
|
|
return gtype;
|
2019-10-20 18:31:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2022-11-08 12:33:26 +00:00
|
|
|
void zip(Context context) throws IOException {
|
|
|
|
File file = getFile(context);
|
|
|
|
File zip = new File(file.getAbsolutePath() + ".zip");
|
|
|
|
|
|
|
|
try (InputStream in = new BufferedInputStream(new FileInputStream(file))) {
|
|
|
|
try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zip)))) {
|
2022-11-08 15:02:54 +00:00
|
|
|
out.setMethod(ZipOutputStream.DEFLATED);
|
|
|
|
out.setLevel(Deflater.BEST_COMPRESSION);
|
2022-11-08 12:33:26 +00:00
|
|
|
ZipEntry entry = new ZipEntry(name);
|
|
|
|
out.putNextEntry(entry);
|
|
|
|
Helper.copy(in, out);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DB db = DB.getInstance(context);
|
|
|
|
db.attachment().setName(id, name + ".zip", "application/zip", zip.length());
|
|
|
|
file.delete();
|
|
|
|
}
|
|
|
|
|
2021-12-08 18:10:42 +00:00
|
|
|
public static boolean equals(List<EntityAttachment> a1, List<EntityAttachment> a2) {
|
|
|
|
if (a1 == null || a2 == null)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
List<EntityAttachment> list = new ArrayList<>();
|
|
|
|
|
|
|
|
for (EntityAttachment a : a1)
|
|
|
|
if (a.available && !a.isEncryption())
|
|
|
|
list.add(a);
|
|
|
|
|
|
|
|
for (EntityAttachment a : a2)
|
|
|
|
if (a.available && !a.isEncryption()) {
|
|
|
|
boolean found = false;
|
|
|
|
for (EntityAttachment l : list)
|
|
|
|
if (Objects.equals(a.sequence, l.sequence) &&
|
|
|
|
Objects.equals(a.subsequence, l.subsequence)) {
|
|
|
|
list.remove(l);
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (list.size() == 0);
|
|
|
|
}
|
|
|
|
|
2018-08-04 19:50:41 +00:00
|
|
|
@Override
|
|
|
|
public boolean equals(Object obj) {
|
|
|
|
if (obj instanceof EntityAttachment) {
|
|
|
|
EntityAttachment other = (EntityAttachment) obj;
|
2023-06-21 10:23:21 +00:00
|
|
|
return (Objects.equals(this.section, other.section) &&
|
|
|
|
this.message.equals(other.message) &&
|
2018-08-04 19:50:41 +00:00
|
|
|
this.sequence.equals(other.sequence) &&
|
2019-02-26 10:05:21 +00:00
|
|
|
Objects.equals(this.name, other.name) &&
|
2018-08-04 19:50:41 +00:00
|
|
|
this.type.equals(other.type) &&
|
2019-02-26 10:05:21 +00:00
|
|
|
Objects.equals(this.disposition, other.disposition) &&
|
|
|
|
Objects.equals(this.cid, other.cid) &&
|
|
|
|
Objects.equals(this.encryption, other.encryption) &&
|
|
|
|
Objects.equals(this.size, other.size) &&
|
|
|
|
Objects.equals(this.progress, other.progress) &&
|
2019-11-30 17:41:07 +00:00
|
|
|
this.available.equals(other.available) &&
|
|
|
|
Objects.equals(this.error, other.error));
|
2018-08-04 19:50:41 +00:00
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
}
|
2019-05-12 13:29:18 +00:00
|
|
|
|
|
|
|
@NonNull
|
|
|
|
@Override
|
|
|
|
public String toString() {
|
2019-05-16 18:44:42 +00:00
|
|
|
return (this.name +
|
|
|
|
" type=" + this.type +
|
|
|
|
" disposition=" + this.disposition +
|
|
|
|
" cid=" + this.cid +
|
|
|
|
" encryption=" + this.encryption +
|
|
|
|
" size=" + this.size);
|
2019-05-12 13:29:18 +00:00
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|