2019-01-19 13:21:21 +00:00
|
|
|
package eu.faircode.email;
|
|
|
|
|
2019-05-04 20:49:22 +00:00
|
|
|
/*
|
|
|
|
This file is part of FairEmail.
|
|
|
|
|
|
|
|
FairEmail 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.
|
|
|
|
|
|
|
|
FairEmail 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 FairEmail. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2021-01-01 07:56:36 +00:00
|
|
|
Copyright 2018-2021 by Marcel Bokhorst (M66B)
|
2019-05-04 20:49:22 +00:00
|
|
|
*/
|
|
|
|
|
2019-01-19 13:21:21 +00:00
|
|
|
import android.Manifest;
|
|
|
|
import android.content.ContentResolver;
|
|
|
|
import android.content.Context;
|
2019-01-26 09:58:37 +00:00
|
|
|
import android.content.SharedPreferences;
|
2019-05-06 17:19:37 +00:00
|
|
|
import android.database.ContentObserver;
|
2019-01-19 13:21:21 +00:00
|
|
|
import android.database.Cursor;
|
|
|
|
import android.graphics.Bitmap;
|
|
|
|
import android.graphics.BitmapFactory;
|
2020-07-28 15:18:13 +00:00
|
|
|
import android.graphics.Canvas;
|
|
|
|
import android.graphics.Color;
|
2020-07-01 09:05:18 +00:00
|
|
|
import android.net.ConnectivityManager;
|
|
|
|
import android.net.NetworkInfo;
|
2019-01-19 13:21:21 +00:00
|
|
|
import android.net.Uri;
|
|
|
|
import android.provider.ContactsContract;
|
2020-05-06 20:30:47 +00:00
|
|
|
import android.text.TextUtils;
|
2019-01-19 13:21:21 +00:00
|
|
|
|
2020-02-09 11:14:11 +00:00
|
|
|
import androidx.annotation.NonNull;
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.preference.PreferenceManager;
|
|
|
|
|
2020-06-30 09:19:17 +00:00
|
|
|
import org.jsoup.nodes.Document;
|
|
|
|
import org.jsoup.nodes.Element;
|
2020-12-11 08:21:01 +00:00
|
|
|
import org.jsoup.select.Elements;
|
2020-06-30 09:19:17 +00:00
|
|
|
|
|
|
|
import java.io.BufferedOutputStream;
|
|
|
|
import java.io.File;
|
2020-06-30 12:04:50 +00:00
|
|
|
import java.io.FileNotFoundException;
|
2020-06-30 09:19:17 +00:00
|
|
|
import java.io.FileOutputStream;
|
2020-01-17 15:59:29 +00:00
|
|
|
import java.io.IOException;
|
2019-01-19 13:21:21 +00:00
|
|
|
import java.io.InputStream;
|
2020-06-30 09:19:17 +00:00
|
|
|
import java.io.OutputStream;
|
2020-05-06 20:30:47 +00:00
|
|
|
import java.io.UnsupportedEncodingException;
|
2020-06-30 12:04:50 +00:00
|
|
|
import java.net.ConnectException;
|
2020-01-17 15:59:29 +00:00
|
|
|
import java.net.HttpURLConnection;
|
2020-07-01 09:05:18 +00:00
|
|
|
import java.net.SocketTimeoutException;
|
2020-01-17 15:59:29 +00:00
|
|
|
import java.net.URL;
|
2020-06-30 12:04:50 +00:00
|
|
|
import java.net.UnknownHostException;
|
2020-05-06 20:30:47 +00:00
|
|
|
import java.nio.charset.StandardCharsets;
|
2020-07-01 12:28:13 +00:00
|
|
|
import java.security.cert.CertPathValidatorException;
|
2020-06-30 12:04:50 +00:00
|
|
|
import java.security.cert.CertificateException;
|
2020-07-01 08:49:09 +00:00
|
|
|
import java.util.ArrayList;
|
2021-04-25 09:27:34 +00:00
|
|
|
import java.util.Arrays;
|
2020-12-11 09:06:48 +00:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Comparator;
|
2019-01-25 13:13:58 +00:00
|
|
|
import java.util.Date;
|
|
|
|
import java.util.HashMap;
|
2020-07-01 08:49:09 +00:00
|
|
|
import java.util.List;
|
2020-02-15 14:53:11 +00:00
|
|
|
import java.util.Locale;
|
2019-01-25 13:13:58 +00:00
|
|
|
import java.util.Map;
|
2020-07-01 08:49:09 +00:00
|
|
|
import java.util.concurrent.Callable;
|
2019-05-06 17:19:37 +00:00
|
|
|
import java.util.concurrent.ConcurrentHashMap;
|
2020-07-01 08:49:09 +00:00
|
|
|
import java.util.concurrent.ExecutionException;
|
2019-07-24 06:52:38 +00:00
|
|
|
import java.util.concurrent.ExecutorService;
|
2020-07-01 08:49:09 +00:00
|
|
|
import java.util.concurrent.Future;
|
2019-01-19 13:21:21 +00:00
|
|
|
|
|
|
|
import javax.mail.Address;
|
|
|
|
import javax.mail.internet.InternetAddress;
|
2020-12-11 07:32:11 +00:00
|
|
|
import javax.net.ssl.HostnameVerifier;
|
2020-06-30 09:19:17 +00:00
|
|
|
import javax.net.ssl.HttpsURLConnection;
|
2020-06-30 12:04:50 +00:00
|
|
|
import javax.net.ssl.SSLException;
|
|
|
|
import javax.net.ssl.SSLHandshakeException;
|
|
|
|
import javax.net.ssl.SSLPeerUnverifiedException;
|
|
|
|
import javax.net.ssl.SSLProtocolException;
|
2020-12-11 07:32:11 +00:00
|
|
|
import javax.net.ssl.SSLSession;
|
2019-01-19 13:21:21 +00:00
|
|
|
|
|
|
|
public class ContactInfo {
|
2019-01-26 09:58:37 +00:00
|
|
|
private String email;
|
|
|
|
private Bitmap bitmap;
|
2019-01-19 13:21:21 +00:00
|
|
|
private String displayName;
|
|
|
|
private Uri lookupUri;
|
2019-10-02 11:36:07 +00:00
|
|
|
private boolean known;
|
2019-01-25 13:13:58 +00:00
|
|
|
private long time;
|
|
|
|
|
2020-05-06 20:30:47 +00:00
|
|
|
private static Map<String, Lookup> emailLookup = new ConcurrentHashMap<>();
|
2019-10-02 11:36:07 +00:00
|
|
|
private static final Map<String, ContactInfo> emailContactInfo = new HashMap<>();
|
2020-01-26 08:13:42 +00:00
|
|
|
private static final Map<String, Avatar> emailGravatar = new HashMap<>();
|
2020-06-30 09:19:17 +00:00
|
|
|
|
2020-07-01 08:49:09 +00:00
|
|
|
private static final ExecutorService executorLookup =
|
2019-10-10 11:26:44 +00:00
|
|
|
Helper.getBackgroundExecutor(1, "contact");
|
2019-07-24 06:52:38 +00:00
|
|
|
|
2020-07-01 08:49:09 +00:00
|
|
|
private static final ExecutorService executorFavicon =
|
|
|
|
Helper.getBackgroundExecutor(0, "favicon");
|
|
|
|
|
2020-12-11 09:06:48 +00:00
|
|
|
private static final int GENERATED_ICON_SIZE = 96; // dp
|
|
|
|
private static final int FAVICON_ICON_SIZE = 64; // dp
|
2020-01-21 10:12:28 +00:00
|
|
|
private static final int GRAVATAR_TIMEOUT = 5 * 1000; // milliseconds
|
2020-06-30 12:04:50 +00:00
|
|
|
private static final int FAVICON_CONNECT_TIMEOUT = 5 * 1000; // milliseconds
|
|
|
|
private static final int FAVICON_READ_TIMEOUT = 10 * 1000; // milliseconds
|
2020-06-30 12:29:50 +00:00
|
|
|
private static final int FAVICON_READ_BYTES = 2048;
|
2020-01-21 10:12:28 +00:00
|
|
|
private static final long CACHE_CONTACT_DURATION = 2 * 60 * 1000L; // milliseconds
|
2020-01-23 15:47:10 +00:00
|
|
|
private static final long CACHE_GRAVATAR_DURATION = 2 * 60 * 60 * 1000L; // milliseconds
|
2020-10-19 10:47:51 +00:00
|
|
|
private static final long CACHE_FAVICON_DURATION = 2 * 7 * 24 * 60 * 60 * 1000L; // milliseconds
|
2019-01-19 13:21:21 +00:00
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
private ContactInfo() {
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
boolean hasPhoto() {
|
|
|
|
return (bitmap != null);
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Bitmap getPhotoBitmap() {
|
2019-01-26 09:58:37 +00:00
|
|
|
return bitmap;
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
|
|
|
|
2020-05-05 20:39:58 +00:00
|
|
|
String getEmailAddress() {
|
|
|
|
return email;
|
|
|
|
}
|
|
|
|
|
2019-12-19 20:37:09 +00:00
|
|
|
String getDisplayName() {
|
|
|
|
return displayName;
|
|
|
|
}
|
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
boolean hasLookupUri() {
|
|
|
|
return (lookupUri != null);
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Uri getLookupUri() {
|
|
|
|
return lookupUri;
|
|
|
|
}
|
|
|
|
|
2019-10-02 11:36:07 +00:00
|
|
|
boolean isKnown() {
|
|
|
|
return known;
|
|
|
|
}
|
|
|
|
|
2019-01-25 13:13:58 +00:00
|
|
|
private boolean isExpired() {
|
2019-03-31 07:09:32 +00:00
|
|
|
return (new Date().getTime() - time > CACHE_CONTACT_DURATION);
|
2019-01-25 13:13:58 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 10:47:51 +00:00
|
|
|
static void cleanup(Context context) {
|
|
|
|
long now = new Date().getTime();
|
|
|
|
|
|
|
|
// Favicons
|
|
|
|
Log.i("Cleanup favicons");
|
|
|
|
File[] favicons = new File(context.getCacheDir(), "favicons").listFiles();
|
|
|
|
if (favicons != null)
|
|
|
|
for (File file : favicons)
|
|
|
|
if (file.lastModified() + CACHE_FAVICON_DURATION < now) {
|
|
|
|
Log.i("Deleting " + file);
|
|
|
|
if (!file.delete())
|
|
|
|
Log.w("Error deleting " + file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-30 10:51:16 +00:00
|
|
|
static void clearCache(Context context) {
|
2020-09-27 08:42:12 +00:00
|
|
|
clearCache(context, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clearCache(Context context, boolean files) {
|
2019-01-26 09:58:37 +00:00
|
|
|
synchronized (emailContactInfo) {
|
|
|
|
emailContactInfo.clear();
|
|
|
|
}
|
2020-06-30 10:51:16 +00:00
|
|
|
|
2020-09-27 08:42:12 +00:00
|
|
|
synchronized (emailGravatar) {
|
|
|
|
emailGravatar.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!files)
|
|
|
|
return;
|
2020-06-30 10:51:16 +00:00
|
|
|
|
2020-09-27 08:42:12 +00:00
|
|
|
final File dir = new File(context.getCacheDir(), "favicons");
|
2020-07-01 08:49:09 +00:00
|
|
|
executorFavicon.submit(new Runnable() {
|
2020-06-30 10:51:16 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
File[] favicons = dir.listFiles();
|
|
|
|
if (favicons != null)
|
|
|
|
for (File favicon : favicons)
|
|
|
|
favicon.delete();
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2019-01-26 09:58:37 +00:00
|
|
|
}
|
2019-01-19 13:21:21 +00:00
|
|
|
|
2020-02-09 11:14:11 +00:00
|
|
|
@NonNull
|
2020-07-05 06:59:10 +00:00
|
|
|
static ContactInfo[] get(Context context, long account, String folderType, Address[] addresses) {
|
|
|
|
return get(context, account, folderType, addresses, false);
|
2020-02-09 11:14:11 +00:00
|
|
|
}
|
|
|
|
|
2020-07-05 06:59:10 +00:00
|
|
|
static ContactInfo[] getCached(Context context, long account, String folderType, Address[] addresses) {
|
|
|
|
return get(context, account, folderType, addresses, true);
|
2020-02-09 11:14:11 +00:00
|
|
|
}
|
|
|
|
|
2020-07-05 06:59:10 +00:00
|
|
|
private static ContactInfo[] get(Context context, long account, String folderType, Address[] addresses, boolean cacheOnly) {
|
2019-01-26 09:58:37 +00:00
|
|
|
if (addresses == null || addresses.length == 0)
|
2020-02-09 11:14:11 +00:00
|
|
|
return new ContactInfo[]{new ContactInfo()};
|
|
|
|
|
|
|
|
ContactInfo[] result = new ContactInfo[addresses.length];
|
|
|
|
for (int i = 0; i < addresses.length; i++) {
|
2020-07-05 06:59:10 +00:00
|
|
|
result[i] = _get(context, account, folderType, (InternetAddress) addresses[i], cacheOnly);
|
2020-02-09 11:14:11 +00:00
|
|
|
if (result[i] == null)
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2019-01-25 13:13:58 +00:00
|
|
|
|
2020-07-05 06:59:10 +00:00
|
|
|
private static ContactInfo _get(Context context, long account, String folderType, InternetAddress address, boolean cacheOnly) {
|
2019-10-14 10:22:07 +00:00
|
|
|
String key = MessageHelper.formatAddresses(new Address[]{address});
|
2019-01-25 13:13:58 +00:00
|
|
|
synchronized (emailContactInfo) {
|
2019-01-30 08:06:10 +00:00
|
|
|
ContactInfo info = emailContactInfo.get(key);
|
2019-01-25 13:13:58 +00:00
|
|
|
if (info != null && !info.isExpired())
|
|
|
|
return info;
|
|
|
|
}
|
2019-01-26 09:58:37 +00:00
|
|
|
|
|
|
|
if (cacheOnly)
|
2019-01-25 13:13:58 +00:00
|
|
|
return null;
|
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
ContactInfo info = new ContactInfo();
|
2019-01-30 08:06:10 +00:00
|
|
|
info.email = address.getAddress();
|
2019-01-26 09:58:37 +00:00
|
|
|
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
2020-03-23 06:42:31 +00:00
|
|
|
boolean avatars = prefs.getBoolean("avatars", true);
|
|
|
|
boolean gravatars = prefs.getBoolean("gravatars", false);
|
2020-06-30 09:19:17 +00:00
|
|
|
boolean favicons = prefs.getBoolean("favicons", false);
|
2020-03-23 06:42:31 +00:00
|
|
|
boolean generated = prefs.getBoolean("generated_icons", true);
|
|
|
|
boolean identicons = prefs.getBoolean("identicons", false);
|
|
|
|
boolean circular = prefs.getBoolean("circular", true);
|
2019-01-26 09:58:37 +00:00
|
|
|
|
2020-06-30 09:19:17 +00:00
|
|
|
// Contact photo
|
2020-06-25 12:32:04 +00:00
|
|
|
if (!TextUtils.isEmpty(info.email) &&
|
|
|
|
Helper.hasPermission(context, Manifest.permission.READ_CONTACTS)) {
|
2019-07-23 16:51:03 +00:00
|
|
|
ContentResolver resolver = context.getContentResolver();
|
2019-10-23 07:35:55 +00:00
|
|
|
Uri uri = Uri.withAppendedPath(
|
|
|
|
ContactsContract.CommonDataKinds.Email.CONTENT_LOOKUP_URI,
|
2020-06-25 12:32:04 +00:00
|
|
|
Uri.encode(info.email.toLowerCase(Locale.ROOT)));
|
2019-10-23 07:35:55 +00:00
|
|
|
try (Cursor cursor = resolver.query(uri,
|
2019-07-23 16:51:03 +00:00
|
|
|
new String[]{
|
|
|
|
ContactsContract.CommonDataKinds.Photo.CONTACT_ID,
|
|
|
|
ContactsContract.Contacts.LOOKUP_KEY,
|
|
|
|
ContactsContract.Contacts.DISPLAY_NAME
|
|
|
|
},
|
2019-10-23 07:35:55 +00:00
|
|
|
null, null, null)) {
|
2019-07-23 16:51:03 +00:00
|
|
|
|
|
|
|
if (cursor != null && cursor.moveToNext()) {
|
|
|
|
int colContactId = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Photo.CONTACT_ID);
|
|
|
|
int colLookupKey = cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY);
|
|
|
|
int colDisplayName = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
|
|
|
|
|
|
|
|
long contactId = cursor.getLong(colContactId);
|
|
|
|
String lookupKey = cursor.getString(colLookupKey);
|
|
|
|
Uri lookupUri = ContactsContract.Contacts.getLookupUri(contactId, lookupKey);
|
|
|
|
|
2020-04-15 16:01:45 +00:00
|
|
|
if (avatars)
|
|
|
|
try (InputStream is = ContactsContract.Contacts.openContactPhotoInputStream(
|
|
|
|
resolver, lookupUri, false)) {
|
|
|
|
info.bitmap = BitmapFactory.decodeStream(is);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-07-23 16:51:03 +00:00
|
|
|
|
|
|
|
info.displayName = cursor.getString(colDisplayName);
|
|
|
|
info.lookupUri = lookupUri;
|
2019-10-02 11:36:07 +00:00
|
|
|
info.known = true;
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
2019-01-26 09:58:37 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-07-23 16:51:03 +00:00
|
|
|
}
|
2019-01-26 09:58:37 +00:00
|
|
|
|
2020-06-30 09:19:17 +00:00
|
|
|
// Gravatar
|
2020-06-30 10:28:31 +00:00
|
|
|
if (info.bitmap == null && gravatars) {
|
|
|
|
if (!TextUtils.isEmpty(info.email)) {
|
2020-06-25 12:32:04 +00:00
|
|
|
String gkey = info.email.toLowerCase(Locale.ROOT);
|
2020-01-23 15:47:10 +00:00
|
|
|
boolean lookup;
|
|
|
|
synchronized (emailGravatar) {
|
2020-04-30 11:59:55 +00:00
|
|
|
Avatar avatar = emailGravatar.get(gkey);
|
2020-01-26 08:13:42 +00:00
|
|
|
lookup = (avatar == null || avatar.isExpired() || avatar.isAvailable());
|
2020-01-23 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lookup) {
|
|
|
|
HttpURLConnection urlConnection = null;
|
|
|
|
try {
|
2020-04-30 11:59:55 +00:00
|
|
|
String hash = Helper.md5(gkey.getBytes());
|
2020-01-23 15:47:10 +00:00
|
|
|
URL url = new URL("https://www.gravatar.com/avatar/" + hash + "?d=404");
|
2020-04-30 11:59:55 +00:00
|
|
|
Log.i("Gravatar key=" + gkey + " url=" + url);
|
2020-01-23 15:47:10 +00:00
|
|
|
|
|
|
|
urlConnection = (HttpURLConnection) url.openConnection();
|
|
|
|
urlConnection.setRequestMethod("GET");
|
|
|
|
urlConnection.setDoOutput(false);
|
|
|
|
urlConnection.setReadTimeout(GRAVATAR_TIMEOUT);
|
|
|
|
urlConnection.setConnectTimeout(GRAVATAR_TIMEOUT);
|
2021-05-14 09:47:14 +00:00
|
|
|
urlConnection.setRequestProperty("User-Agent", WebViewEx.getUserAgent(context));
|
2020-01-23 15:47:10 +00:00
|
|
|
urlConnection.connect();
|
|
|
|
|
|
|
|
int status = urlConnection.getResponseCode();
|
|
|
|
if (status == HttpURLConnection.HTTP_OK) {
|
|
|
|
info.bitmap = BitmapFactory.decodeStream(urlConnection.getInputStream());
|
2020-01-26 08:13:42 +00:00
|
|
|
// Positive reply
|
2020-01-23 15:47:10 +00:00
|
|
|
synchronized (emailGravatar) {
|
2020-04-30 11:59:55 +00:00
|
|
|
emailGravatar.put(gkey, new Avatar(true));
|
2020-01-23 15:47:10 +00:00
|
|
|
}
|
|
|
|
} else if (status == HttpURLConnection.HTTP_NOT_FOUND) {
|
2020-01-26 08:13:42 +00:00
|
|
|
// Negative reply
|
2020-01-23 15:47:10 +00:00
|
|
|
synchronized (emailGravatar) {
|
2020-04-30 11:59:55 +00:00
|
|
|
emailGravatar.put(gkey, new Avatar(false));
|
2020-01-23 15:47:10 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
throw new IOException("HTTP status=" + status);
|
|
|
|
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
} finally {
|
|
|
|
if (urlConnection != null)
|
|
|
|
urlConnection.disconnect();
|
|
|
|
}
|
2020-01-17 15:59:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-30 09:19:17 +00:00
|
|
|
// Favicon
|
2020-07-05 06:59:10 +00:00
|
|
|
if (info.bitmap == null && favicons &&
|
|
|
|
!EntityFolder.JUNK.equals(folderType)) {
|
2020-06-30 09:19:17 +00:00
|
|
|
int at = (info.email == null ? -1 : info.email.indexOf('@'));
|
|
|
|
String domain = (at < 0 ? null : info.email.substring(at + 1).toLowerCase(Locale.ROOT));
|
2020-06-30 10:28:31 +00:00
|
|
|
|
|
|
|
if (domain != null) {
|
2020-06-30 12:29:50 +00:00
|
|
|
if ("gmail.com".equals(domain) || "googlemail.com".equals(domain))
|
2020-06-30 10:35:38 +00:00
|
|
|
domain = "google.com";
|
|
|
|
|
2020-06-30 10:51:16 +00:00
|
|
|
File dir = new File(context.getCacheDir(), "favicons");
|
|
|
|
if (!dir.exists())
|
|
|
|
dir.mkdir();
|
|
|
|
File file = new File(dir, domain);
|
|
|
|
|
2020-06-30 09:19:17 +00:00
|
|
|
try {
|
2020-06-30 10:28:31 +00:00
|
|
|
// check cache
|
2020-06-30 09:19:17 +00:00
|
|
|
if (file.exists())
|
2020-06-30 10:51:16 +00:00
|
|
|
if (file.length() == 0)
|
|
|
|
Log.i("Favicon blacklisted domain=" + domain);
|
|
|
|
else
|
|
|
|
info.bitmap = BitmapFactory.decodeFile(file.getAbsolutePath());
|
2020-06-30 09:19:17 +00:00
|
|
|
else {
|
2020-12-11 09:06:48 +00:00
|
|
|
final int scaleToPixels = Helper.dp2pixels(context, FAVICON_ICON_SIZE);
|
2020-07-01 07:59:48 +00:00
|
|
|
|
2020-07-01 08:49:09 +00:00
|
|
|
List<Future<Bitmap>> futures = new ArrayList<>();
|
2020-06-30 12:04:50 +00:00
|
|
|
|
2020-12-10 19:56:47 +00:00
|
|
|
String host = domain;
|
|
|
|
while (host.indexOf('.') > 0) {
|
|
|
|
final URL base = new URL("https://" + host);
|
|
|
|
final URL www = new URL("https://www." + host);
|
|
|
|
|
|
|
|
futures.add(executorFavicon.submit(new Callable<Bitmap>() {
|
|
|
|
@Override
|
|
|
|
public Bitmap call() throws Exception {
|
2021-05-14 09:47:14 +00:00
|
|
|
return parseFavicon(base, scaleToPixels, context);
|
2020-12-10 19:56:47 +00:00
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
futures.add(executorFavicon.submit(new Callable<Bitmap>() {
|
|
|
|
@Override
|
|
|
|
public Bitmap call() throws Exception {
|
2021-05-14 09:47:14 +00:00
|
|
|
return parseFavicon(www, scaleToPixels, context);
|
2020-12-10 19:56:47 +00:00
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
futures.add(executorFavicon.submit(new Callable<Bitmap>() {
|
|
|
|
@Override
|
|
|
|
public Bitmap call() throws Exception {
|
2021-05-14 09:47:14 +00:00
|
|
|
return getFavicon(new URL(base, "favicon.ico"), scaleToPixels, context);
|
2020-12-10 19:56:47 +00:00
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
futures.add(executorFavicon.submit(new Callable<Bitmap>() {
|
|
|
|
@Override
|
|
|
|
public Bitmap call() throws Exception {
|
2021-05-14 09:47:14 +00:00
|
|
|
return getFavicon(new URL(www, "favicon.ico"), scaleToPixels, context);
|
2020-12-10 19:56:47 +00:00
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
int dot = host.indexOf('.');
|
|
|
|
host = host.substring(dot + 1);
|
|
|
|
}
|
2020-07-01 08:49:09 +00:00
|
|
|
|
|
|
|
Throwable ex = null;
|
|
|
|
for (Future<Bitmap> future : futures)
|
2020-07-01 07:59:48 +00:00
|
|
|
try {
|
2020-07-01 08:49:09 +00:00
|
|
|
info.bitmap = future.get();
|
2020-07-01 11:04:19 +00:00
|
|
|
if (info.bitmap != null)
|
|
|
|
break;
|
2020-07-01 08:49:09 +00:00
|
|
|
} catch (ExecutionException exex) {
|
|
|
|
ex = exex.getCause();
|
|
|
|
} catch (Throwable exex) {
|
|
|
|
ex = exex;
|
2020-07-01 07:59:48 +00:00
|
|
|
}
|
2020-06-30 09:19:17 +00:00
|
|
|
|
2020-06-30 12:29:50 +00:00
|
|
|
if (info.bitmap == null)
|
2020-07-01 08:49:09 +00:00
|
|
|
throw ex;
|
|
|
|
|
|
|
|
// Add to cache
|
|
|
|
try (OutputStream os = new BufferedOutputStream(new FileOutputStream(file))) {
|
|
|
|
info.bitmap.compress(Bitmap.CompressFormat.PNG, 90, os);
|
|
|
|
}
|
2020-06-30 09:19:17 +00:00
|
|
|
}
|
|
|
|
} catch (Throwable ex) {
|
2020-07-06 15:39:21 +00:00
|
|
|
if (isRecoverable(ex, context))
|
|
|
|
Log.i(ex);
|
|
|
|
else {
|
2021-03-13 20:25:27 +00:00
|
|
|
if (ex instanceof FileNotFoundException ||
|
|
|
|
ex instanceof CertPathValidatorException)
|
|
|
|
Log.i(ex);
|
|
|
|
else
|
|
|
|
Log.e(ex);
|
2020-06-30 10:51:16 +00:00
|
|
|
try {
|
|
|
|
file.createNewFile();
|
2020-06-30 12:04:50 +00:00
|
|
|
} catch (IOException ex1) {
|
|
|
|
Log.e(ex1);
|
2020-06-30 09:19:17 +00:00
|
|
|
}
|
2020-07-06 15:39:21 +00:00
|
|
|
}
|
2020-06-30 09:19:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generated
|
2019-09-30 18:27:36 +00:00
|
|
|
boolean identicon = false;
|
2020-06-30 10:28:31 +00:00
|
|
|
if (info.bitmap == null && generated) {
|
2020-12-11 09:06:48 +00:00
|
|
|
int dp = Helper.dp2pixels(context, GENERATED_ICON_SIZE);
|
2020-06-30 10:28:31 +00:00
|
|
|
if (!TextUtils.isEmpty(info.email)) {
|
2019-09-30 18:27:36 +00:00
|
|
|
if (identicons) {
|
|
|
|
identicon = true;
|
2019-10-13 11:54:18 +00:00
|
|
|
info.bitmap = ImageHelper.generateIdenticon(
|
2020-06-25 12:32:04 +00:00
|
|
|
info.email, dp, 5, context);
|
2019-09-30 18:27:36 +00:00
|
|
|
} else
|
2019-10-13 11:54:18 +00:00
|
|
|
info.bitmap = ImageHelper.generateLetterIcon(
|
2020-06-25 12:32:04 +00:00
|
|
|
info.email, address.getPersonal(), dp, context);
|
2019-07-22 08:40:03 +00:00
|
|
|
}
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
|
|
|
|
2019-10-13 09:14:06 +00:00
|
|
|
info.bitmap = ImageHelper.makeCircular(info.bitmap,
|
|
|
|
circular && !identicon ? null : Helper.dp2pixels(context, 3));
|
2019-04-25 19:20:20 +00:00
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
if (info.displayName == null)
|
|
|
|
info.displayName = address.getPersonal();
|
|
|
|
|
2020-06-25 12:32:04 +00:00
|
|
|
if (!info.known && !TextUtils.isEmpty(info.email)) {
|
2019-10-02 11:36:07 +00:00
|
|
|
DB db = DB.getInstance(context);
|
|
|
|
EntityContact contact = db.contact().getContact(account, EntityContact.TYPE_TO, info.email);
|
|
|
|
info.known = (contact != null);
|
|
|
|
}
|
|
|
|
|
2019-01-26 09:58:37 +00:00
|
|
|
synchronized (emailContactInfo) {
|
2019-01-30 08:06:10 +00:00
|
|
|
emailContactInfo.put(key, info);
|
2019-01-26 09:58:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
info.time = new Date().getTime();
|
|
|
|
return info;
|
2019-01-19 13:21:21 +00:00
|
|
|
}
|
2019-02-04 11:45:38 +00:00
|
|
|
|
2021-05-14 09:47:14 +00:00
|
|
|
private static Bitmap parseFavicon(URL base, int scaleToPixels, Context context) throws IOException {
|
2020-06-30 12:04:50 +00:00
|
|
|
Log.i("GET favicon " + base);
|
|
|
|
HttpsURLConnection connection = (HttpsURLConnection) base.openConnection();
|
|
|
|
connection.setRequestMethod("GET");
|
|
|
|
connection.setReadTimeout(FAVICON_READ_TIMEOUT);
|
|
|
|
connection.setConnectTimeout(FAVICON_CONNECT_TIMEOUT);
|
|
|
|
connection.setInstanceFollowRedirects(true);
|
2020-12-11 07:32:11 +00:00
|
|
|
connection.setHostnameVerifier(new HostnameVerifier() {
|
|
|
|
@Override
|
|
|
|
public boolean verify(String hostname, SSLSession session) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
});
|
2021-05-14 09:47:14 +00:00
|
|
|
connection.setRequestProperty("User-Agent", WebViewEx.getUserAgent(context));
|
2020-06-30 12:04:50 +00:00
|
|
|
connection.connect();
|
2020-06-30 10:28:31 +00:00
|
|
|
|
2020-06-30 12:04:50 +00:00
|
|
|
String response;
|
|
|
|
try {
|
2020-06-30 12:29:50 +00:00
|
|
|
byte[] buffer = new byte[FAVICON_READ_BYTES];
|
|
|
|
int len = connection.getInputStream().read(buffer);
|
|
|
|
if (len < 0)
|
|
|
|
throw new IOException("length");
|
|
|
|
response = new String(buffer, 0, len, StandardCharsets.UTF_8.name());
|
2020-06-30 12:04:50 +00:00
|
|
|
} finally {
|
|
|
|
connection.disconnect();
|
|
|
|
}
|
2020-06-30 10:28:31 +00:00
|
|
|
|
2020-06-30 12:04:50 +00:00
|
|
|
Document doc = JsoupEx.parse(response);
|
2020-06-30 10:28:31 +00:00
|
|
|
|
2020-12-11 08:21:01 +00:00
|
|
|
// Use canonical address
|
2020-12-10 21:10:18 +00:00
|
|
|
Element canonical = doc.head().select("link[rel=canonical]").first();
|
|
|
|
if (canonical != null) {
|
|
|
|
String href = canonical.attr("href");
|
|
|
|
if (!TextUtils.isEmpty(href))
|
|
|
|
base = new URL(href);
|
|
|
|
}
|
|
|
|
|
2020-12-11 08:21:01 +00:00
|
|
|
// https://en.wikipedia.org/wiki/Favicon
|
|
|
|
Elements imgs = new Elements();
|
2020-12-11 13:54:15 +00:00
|
|
|
imgs.addAll(doc.head().select("link[href~=.+\\.(ico|png|gif|svg)]"));
|
|
|
|
imgs.addAll(doc.head().select("meta[itemprop=image]"));
|
2020-12-11 08:21:01 +00:00
|
|
|
|
2020-12-11 09:06:48 +00:00
|
|
|
Collections.sort(imgs, new Comparator<Element>() {
|
|
|
|
@Override
|
|
|
|
public int compare(Element img1, Element img2) {
|
2020-12-11 18:53:10 +00:00
|
|
|
boolean l1 = "link".equals(img1.tagName());
|
|
|
|
boolean l2 = "link".equals(img2.tagName());
|
|
|
|
int l = Boolean.compare(l1, l2);
|
|
|
|
if (l != 0)
|
|
|
|
return -l;
|
|
|
|
|
2020-12-11 13:54:15 +00:00
|
|
|
boolean i1 = "icon".equalsIgnoreCase(img1.attr("rel")
|
|
|
|
.replace("shortcut", "").trim());
|
|
|
|
boolean i2 = "icon".equalsIgnoreCase(img2.attr("rel")
|
|
|
|
.replace("shortcut", "").trim());
|
|
|
|
int i = Boolean.compare(i1, i2);
|
|
|
|
if (i != 0)
|
|
|
|
return -i;
|
|
|
|
|
2020-12-11 09:06:48 +00:00
|
|
|
String[] s1 = img1.attr("sizes").split("[x|X]");
|
|
|
|
String[] s2 = img2.attr("sizes").split("[x|X]");
|
2020-12-11 13:54:15 +00:00
|
|
|
Integer w1 = Helper.parseInt(s1.length == 2 ? s1[0] : null);
|
|
|
|
Integer h1 = Helper.parseInt(s1.length == 2 ? s1[1] : null);
|
|
|
|
Integer w2 = Helper.parseInt(s2.length == 2 ? s2[0] : null);
|
|
|
|
Integer h2 = Helper.parseInt(s2.length == 2 ? s2[1] : null);
|
2020-12-11 09:06:48 +00:00
|
|
|
return Integer.compare(
|
2020-12-11 13:54:15 +00:00
|
|
|
Math.abs(Math.min(w1 == null ? 0 : w1, h1 == null ? 0 : h1) - scaleToPixels),
|
|
|
|
Math.abs(Math.min(w2 == null ? 0 : w2, h2 == null ? 0 : h2) - scaleToPixels));
|
2020-12-11 09:06:48 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-12-11 13:54:15 +00:00
|
|
|
for (int i = 0; i < imgs.size(); i++)
|
|
|
|
Log.i("Favicon " + i + "=" + imgs.get(i) + " @" + base);
|
|
|
|
|
2020-12-11 08:21:01 +00:00
|
|
|
List<Future<Bitmap>> futures = new ArrayList<>();
|
|
|
|
for (Element img : imgs) {
|
|
|
|
String favicon = ("link".equals(img.tagName())
|
|
|
|
? img.attr("href")
|
|
|
|
: img.attr("content"));
|
2020-12-10 21:09:36 +00:00
|
|
|
if (TextUtils.isEmpty(favicon))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
final URL url = new URL(base, favicon);
|
|
|
|
futures.add(executorFavicon.submit(new Callable<Bitmap>() {
|
|
|
|
@Override
|
|
|
|
public Bitmap call() throws Exception {
|
2021-05-14 09:47:14 +00:00
|
|
|
return getFavicon(url, scaleToPixels, context);
|
2020-12-10 21:09:36 +00:00
|
|
|
}
|
|
|
|
}));
|
2020-06-30 12:04:50 +00:00
|
|
|
}
|
2020-06-30 10:28:31 +00:00
|
|
|
|
2020-12-10 21:09:36 +00:00
|
|
|
for (Future<Bitmap> future : futures)
|
|
|
|
try {
|
|
|
|
return future.get();
|
|
|
|
} catch (Throwable ex) {
|
2021-03-13 20:25:27 +00:00
|
|
|
if (ex.getCause() instanceof FileNotFoundException ||
|
|
|
|
ex.getCause() instanceof CertPathValidatorException)
|
2021-03-13 20:04:49 +00:00
|
|
|
Log.i(ex);
|
|
|
|
else
|
|
|
|
Log.e(ex);
|
2020-12-10 21:09:36 +00:00
|
|
|
}
|
2020-06-30 12:04:50 +00:00
|
|
|
|
|
|
|
return null;
|
2020-06-30 09:19:17 +00:00
|
|
|
}
|
|
|
|
|
2020-07-01 08:49:09 +00:00
|
|
|
@NonNull
|
2021-05-14 09:47:14 +00:00
|
|
|
private static Bitmap getFavicon(URL url, int scaleToPixels, Context context) throws IOException {
|
2020-06-30 10:28:31 +00:00
|
|
|
Log.i("GET favicon " + url);
|
|
|
|
|
2020-07-04 07:08:32 +00:00
|
|
|
if (!"https".equals(url.getProtocol()))
|
|
|
|
throw new FileNotFoundException("http");
|
|
|
|
|
|
|
|
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
|
2020-06-30 10:28:31 +00:00
|
|
|
connection.setRequestMethod("GET");
|
2020-06-30 12:04:50 +00:00
|
|
|
connection.setReadTimeout(FAVICON_READ_TIMEOUT);
|
|
|
|
connection.setConnectTimeout(FAVICON_CONNECT_TIMEOUT);
|
2020-06-30 10:28:31 +00:00
|
|
|
connection.setInstanceFollowRedirects(true);
|
2020-12-11 07:32:11 +00:00
|
|
|
connection.setHostnameVerifier(new HostnameVerifier() {
|
|
|
|
@Override
|
|
|
|
public boolean verify(String hostname, SSLSession session) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
});
|
2021-05-14 09:47:14 +00:00
|
|
|
connection.setRequestProperty("User-Agent", WebViewEx.getUserAgent(context));
|
2020-06-30 10:28:31 +00:00
|
|
|
connection.connect();
|
|
|
|
|
|
|
|
try {
|
2020-08-29 17:25:16 +00:00
|
|
|
Bitmap bitmap = ImageHelper.getScaledBitmap(connection.getInputStream(), url.toString(), scaleToPixels);
|
2020-07-01 08:49:09 +00:00
|
|
|
if (bitmap == null)
|
|
|
|
throw new FileNotFoundException("decodeStream");
|
2020-07-28 15:18:13 +00:00
|
|
|
else {
|
|
|
|
Bitmap favicon = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());
|
|
|
|
favicon.eraseColor(Color.WHITE);
|
|
|
|
Canvas canvas = new Canvas(favicon);
|
|
|
|
canvas.drawBitmap(bitmap, 0, 0, null);
|
|
|
|
bitmap.recycle();
|
|
|
|
return favicon;
|
|
|
|
}
|
2020-06-30 10:28:31 +00:00
|
|
|
} finally {
|
|
|
|
connection.disconnect();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-01 09:05:18 +00:00
|
|
|
private static boolean isRecoverable(Throwable ex, Context context) {
|
|
|
|
if (ex instanceof SocketTimeoutException) {
|
|
|
|
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
NetworkInfo ni = (cm == null ? null : cm.getActiveNetworkInfo());
|
|
|
|
return (ni == null || !ni.isConnected());
|
|
|
|
}
|
|
|
|
|
2020-06-30 12:29:50 +00:00
|
|
|
return !(ex instanceof ConnectException ||
|
|
|
|
(ex instanceof UnknownHostException &&
|
|
|
|
ex.getMessage() != null &&
|
|
|
|
ex.getMessage().contains("No address associated with hostname")) ||
|
2020-06-30 12:04:50 +00:00
|
|
|
ex instanceof FileNotFoundException ||
|
|
|
|
ex instanceof SSLPeerUnverifiedException ||
|
|
|
|
(ex instanceof SSLException &&
|
|
|
|
"Unable to parse TLS packet header".equals(ex.getMessage())) ||
|
|
|
|
(ex instanceof SSLHandshakeException &&
|
2020-07-01 12:28:13 +00:00
|
|
|
("connection closed".equals(ex.getMessage())) ||
|
|
|
|
"Connection closed by peer".equals(ex.getMessage())) ||
|
2020-07-01 17:44:01 +00:00
|
|
|
(ex instanceof SSLHandshakeException &&
|
|
|
|
ex.getMessage() != null &&
|
2020-07-19 06:01:14 +00:00
|
|
|
(ex.getMessage().contains("usually a protocol error") ||
|
|
|
|
ex.getMessage().contains("Unacceptable certificate"))) ||
|
2020-06-30 12:04:50 +00:00
|
|
|
(ex instanceof SSLHandshakeException &&
|
2020-07-01 12:28:13 +00:00
|
|
|
(ex.getCause() instanceof SSLProtocolException ||
|
|
|
|
ex.getCause() instanceof CertificateException ||
|
|
|
|
ex.getCause() instanceof CertPathValidatorException)));
|
2020-06-30 12:04:50 +00:00
|
|
|
}
|
|
|
|
|
2019-07-24 06:52:38 +00:00
|
|
|
static void init(final Context context) {
|
|
|
|
if (Helper.hasPermission(context, Manifest.permission.READ_CONTACTS)) {
|
2020-08-23 15:34:14 +00:00
|
|
|
ContentObserver observer = new ContentObserver(ApplicationEx.getMainHandler()) {
|
2019-07-24 06:52:38 +00:00
|
|
|
@Override
|
|
|
|
public void onChange(boolean selfChange, Uri uri) {
|
|
|
|
Log.i("Contact changed uri=" + uri);
|
2020-07-01 08:49:09 +00:00
|
|
|
executorLookup.submit(new Runnable() {
|
2019-07-24 06:52:38 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
emailLookup = getEmailLookup(context);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-07-23 16:51:03 +00:00
|
|
|
}
|
2019-07-24 06:52:38 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-07-01 08:49:09 +00:00
|
|
|
executorLookup.submit(new Runnable() {
|
2019-07-24 06:52:38 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
emailLookup = getEmailLookup(context);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2019-07-16 10:01:57 +00:00
|
|
|
}
|
2019-07-24 06:52:38 +00:00
|
|
|
}
|
|
|
|
});
|
2019-07-23 16:51:03 +00:00
|
|
|
|
2020-06-28 07:50:49 +00:00
|
|
|
try {
|
|
|
|
Uri uri = ContactsContract.CommonDataKinds.Email.CONTENT_URI;
|
|
|
|
Log.i("Observing uri=" + uri);
|
|
|
|
context.getContentResolver().registerContentObserver(uri, true, observer);
|
|
|
|
} catch (SecurityException ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
/*
|
|
|
|
Should never happen, but:
|
|
|
|
Caused by: android.os.RemoteException:
|
|
|
|
at com.android.server.content.ContentService.registerContentObserver (ContentService.java:340)
|
|
|
|
at android.content.IContentService$Stub.onTransact (IContentService.java:76)
|
|
|
|
at com.android.server.content.ContentService.onTransact (ContentService.java:262)
|
|
|
|
at android.os.Binder.execTransact (Binder.java:731)
|
|
|
|
*/
|
|
|
|
}
|
2019-07-24 06:52:38 +00:00
|
|
|
}
|
2019-05-06 17:19:37 +00:00
|
|
|
}
|
|
|
|
|
2020-05-06 20:30:47 +00:00
|
|
|
static Uri getLookupUri(Address[] addresses) {
|
2019-05-06 17:19:37 +00:00
|
|
|
if (addresses == null)
|
2019-02-04 11:45:38 +00:00
|
|
|
return null;
|
|
|
|
|
2019-05-06 17:19:37 +00:00
|
|
|
for (Address from : addresses) {
|
|
|
|
String email = ((InternetAddress) from).getAddress();
|
2020-06-25 12:32:04 +00:00
|
|
|
if (!TextUtils.isEmpty(email)) {
|
|
|
|
Lookup lookup = emailLookup.get(email.toLowerCase(Locale.ROOT));
|
|
|
|
if (lookup != null)
|
|
|
|
return lookup.uri;
|
|
|
|
}
|
2019-04-05 06:33:43 +00:00
|
|
|
}
|
2019-02-04 11:45:38 +00:00
|
|
|
|
2019-05-06 17:19:37 +00:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2021-02-28 16:37:06 +00:00
|
|
|
static Address[] fillIn(Address[] addresses, boolean prefer_contact, boolean only_contact) {
|
2020-05-06 20:30:47 +00:00
|
|
|
if (addresses == null)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
Address[] modified = new Address[addresses.length];
|
|
|
|
for (int i = 0; i < addresses.length; i++) {
|
|
|
|
InternetAddress address = (InternetAddress) addresses[i];
|
|
|
|
String email = address.getAddress();
|
2021-02-28 16:37:06 +00:00
|
|
|
String personal = (only_contact ? null : address.getPersonal());
|
2020-06-25 12:32:04 +00:00
|
|
|
if (!TextUtils.isEmpty(email)) {
|
|
|
|
Lookup lookup = emailLookup.get(email.toLowerCase(Locale.ROOT));
|
|
|
|
if (lookup != null &&
|
|
|
|
(TextUtils.isEmpty(personal) || prefer_contact))
|
2020-05-06 20:30:47 +00:00
|
|
|
personal = lookup.displayName;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
modified[i] = new InternetAddress(email, personal, StandardCharsets.UTF_8.name());
|
|
|
|
} catch (UnsupportedEncodingException ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
modified[i] = address;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return modified;
|
|
|
|
}
|
|
|
|
|
2021-04-25 09:27:34 +00:00
|
|
|
static void update(
|
|
|
|
Context context, EntityAccount account, final EntityFolder folder, final EntityMessage message) {
|
2021-04-25 10:08:33 +00:00
|
|
|
long sync_time = (folder.sync_days == Integer.MAX_VALUE ? 0 : folder.sync_days) * 24 * 3600 * 1000L;
|
|
|
|
if (message.received < account.created - sync_time)
|
2021-04-25 09:27:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (EntityFolder.DRAFTS.equals(folder.type) ||
|
|
|
|
EntityFolder.ARCHIVE.equals(folder.type) ||
|
|
|
|
EntityFolder.TRASH.equals(folder.type) ||
|
|
|
|
EntityFolder.JUNK.equals(folder.type))
|
|
|
|
return;
|
|
|
|
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
boolean suggest_sent = prefs.getBoolean("suggest_sent", true);
|
|
|
|
boolean suggest_received = prefs.getBoolean("suggest_received", false);
|
|
|
|
if (!suggest_sent && !suggest_received)
|
|
|
|
return;
|
|
|
|
|
|
|
|
DB db = DB.getInstance(context);
|
|
|
|
|
|
|
|
int type = (folder.isOutgoing() ? EntityContact.TYPE_TO : EntityContact.TYPE_FROM);
|
|
|
|
|
|
|
|
// Check if from self
|
|
|
|
if (type == EntityContact.TYPE_FROM) {
|
|
|
|
if (message.from != null) {
|
2021-04-25 10:59:11 +00:00
|
|
|
List<EntityIdentity> identities = Core.getIdentities(folder.account, context);
|
2021-04-25 09:27:34 +00:00
|
|
|
if (identities != null) {
|
|
|
|
for (Address sender : message.from) {
|
|
|
|
for (EntityIdentity identity : identities)
|
|
|
|
if (identity.similarAddress(sender)) {
|
|
|
|
type = EntityContact.TYPE_TO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (type == EntityContact.TYPE_TO)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == EntityContact.TYPE_TO && !suggest_sent)
|
|
|
|
return;
|
|
|
|
if (type == EntityContact.TYPE_FROM && !suggest_received)
|
|
|
|
return;
|
|
|
|
|
|
|
|
List<Address> addresses = new ArrayList<>();
|
|
|
|
if (type == EntityContact.TYPE_FROM) {
|
|
|
|
if (message.reply == null || message.reply.length == 0) {
|
|
|
|
if (message.from != null)
|
|
|
|
addresses.addAll(Arrays.asList(message.from));
|
|
|
|
} else
|
|
|
|
addresses.addAll(Arrays.asList(message.reply));
|
|
|
|
} else if (type == EntityContact.TYPE_TO) {
|
|
|
|
if (message.to != null)
|
|
|
|
addresses.addAll(Arrays.asList(message.to));
|
|
|
|
if (message.cc != null)
|
|
|
|
addresses.addAll(Arrays.asList(message.cc));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (Address address : addresses) {
|
|
|
|
String email = ((InternetAddress) address).getAddress();
|
|
|
|
String name = ((InternetAddress) address).getPersonal();
|
|
|
|
Uri avatar = ContactInfo.getLookupUri(new Address[]{address});
|
|
|
|
|
|
|
|
if (TextUtils.isEmpty(email))
|
|
|
|
continue;
|
|
|
|
if (TextUtils.isEmpty(name))
|
|
|
|
name = null;
|
|
|
|
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
EntityContact contact = db.contact().getContact(folder.account, type, email);
|
|
|
|
if (contact == null) {
|
|
|
|
contact = new EntityContact();
|
|
|
|
contact.account = folder.account;
|
|
|
|
contact.type = type;
|
|
|
|
contact.email = email;
|
|
|
|
contact.name = name;
|
|
|
|
contact.avatar = (avatar == null ? null : avatar.toString());
|
|
|
|
contact.times_contacted = 1;
|
|
|
|
contact.first_contacted = message.received;
|
|
|
|
contact.last_contacted = message.received;
|
|
|
|
contact.id = db.contact().insertContact(contact);
|
|
|
|
Log.i("Inserted contact=" + contact + " type=" + type);
|
|
|
|
} else {
|
|
|
|
if (contact.name == null && name != null)
|
|
|
|
contact.name = name;
|
|
|
|
contact.avatar = (avatar == null ? null : avatar.toString());
|
|
|
|
contact.times_contacted++;
|
|
|
|
contact.first_contacted = Math.min(contact.first_contacted, message.received);
|
|
|
|
contact.last_contacted = message.received;
|
|
|
|
db.contact().updateContact(contact);
|
|
|
|
Log.i("Updated contact=" + contact + " type=" + type);
|
|
|
|
}
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-06 20:30:47 +00:00
|
|
|
private static Map<String, Lookup> getEmailLookup(Context context) {
|
|
|
|
Map<String, Lookup> all = new ConcurrentHashMap<>();
|
2019-05-06 17:19:37 +00:00
|
|
|
|
|
|
|
if (Helper.hasPermission(context, Manifest.permission.READ_CONTACTS)) {
|
2019-07-24 06:52:38 +00:00
|
|
|
Log.i("Reading email/uri");
|
2019-02-22 15:59:23 +00:00
|
|
|
ContentResolver resolver = context.getContentResolver();
|
2019-07-21 08:31:34 +00:00
|
|
|
|
2019-02-22 15:59:23 +00:00
|
|
|
try (Cursor cursor = resolver.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI,
|
|
|
|
new String[]{
|
|
|
|
ContactsContract.CommonDataKinds.Photo.CONTACT_ID,
|
2019-05-06 17:19:37 +00:00
|
|
|
ContactsContract.Contacts.LOOKUP_KEY,
|
2020-05-06 20:30:47 +00:00
|
|
|
ContactsContract.CommonDataKinds.Email.ADDRESS,
|
|
|
|
ContactsContract.Contacts.DISPLAY_NAME
|
2019-02-22 15:59:23 +00:00
|
|
|
},
|
2019-05-06 17:19:37 +00:00
|
|
|
ContactsContract.CommonDataKinds.Email.ADDRESS + " <> ''",
|
|
|
|
null, null)) {
|
|
|
|
while (cursor != null && cursor.moveToNext()) {
|
|
|
|
long contactId = cursor.getLong(0);
|
|
|
|
String lookupKey = cursor.getString(1);
|
|
|
|
String email = cursor.getString(2);
|
2020-05-06 20:30:47 +00:00
|
|
|
String displayName = cursor.getString(3);
|
2019-05-06 17:19:37 +00:00
|
|
|
|
2020-05-06 20:30:47 +00:00
|
|
|
Lookup lookup = new Lookup();
|
|
|
|
lookup.uri = ContactsContract.Contacts.getLookupUri(contactId, lookupKey);
|
|
|
|
lookup.displayName = displayName;
|
2020-06-25 12:32:04 +00:00
|
|
|
all.put(email.toLowerCase(Locale.ROOT), lookup);
|
2019-03-31 07:09:32 +00:00
|
|
|
}
|
2019-07-23 16:51:03 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2019-02-04 11:45:38 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-31 07:09:32 +00:00
|
|
|
|
2019-05-06 17:19:37 +00:00
|
|
|
Log.i("Read email/uri=" + all.size());
|
|
|
|
return all;
|
2019-03-31 07:09:32 +00:00
|
|
|
}
|
2020-01-23 15:47:10 +00:00
|
|
|
|
2020-05-06 20:30:47 +00:00
|
|
|
private static class Lookup {
|
|
|
|
Uri uri;
|
|
|
|
String displayName;
|
|
|
|
}
|
|
|
|
|
2020-01-26 08:13:42 +00:00
|
|
|
private static class Avatar {
|
2020-01-23 15:47:10 +00:00
|
|
|
private boolean available;
|
|
|
|
private long time;
|
|
|
|
|
2020-01-26 08:13:42 +00:00
|
|
|
Avatar(boolean available) {
|
2020-01-23 15:47:10 +00:00
|
|
|
this.available = available;
|
|
|
|
this.time = new Date().getTime();
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean isAvailable() {
|
|
|
|
return available;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean isExpired() {
|
|
|
|
return (new Date().getTime() - time > CACHE_GRAVATAR_DURATION);
|
|
|
|
}
|
|
|
|
}
|
2021-04-25 09:27:34 +00:00
|
|
|
}
|