) {
messageStore.destroyMessages(folderId, messageServerIds)
notifyChange()
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/OutboxStateRepository.kt b/app/core/src/main/java/com/fsck/k9/mailstore/OutboxStateRepository.kt
index 794e93af637bb141cfedd50a5c34cf1648f0829f..c2c11aa932f6977b9b137d310384c7c2cbc6609a 100644
--- a/app/core/src/main/java/com/fsck/k9/mailstore/OutboxStateRepository.kt
+++ b/app/core/src/main/java/com/fsck/k9/mailstore/OutboxStateRepository.kt
@@ -2,6 +2,10 @@ package com.fsck.k9.mailstore
import android.content.ContentValues
import com.fsck.k9.Clock
+import com.fsck.k9.helper.getIntOrThrow
+import com.fsck.k9.helper.getLongOrThrow
+import com.fsck.k9.helper.getStringOrNull
+import com.fsck.k9.helper.getStringOrThrow
class OutboxStateRepository(private val database: LockableDatabase, private val clock: Clock) {
@@ -17,11 +21,10 @@ class OutboxStateRepository(private val database: LockableDatabase, private val
throw IllegalStateException("No outbox_state entry for message with id $messageId")
}
- val sendStateString = cursor.getString(cursor.getColumnIndex(COLUMN_SEND_STATE))
- val numberOfSendAttempts = cursor.getInt(cursor.getColumnIndex(COLUMN_NUMBER_OF_SEND_ATTEMPTS))
- val sendErrorTimestamp = cursor.getLong(cursor.getColumnIndex(COLUMN_ERROR_TIMESTAMP))
- val sendErrorColumnIndex = cursor.getColumnIndex(COLUMN_ERROR)
- val sendError = if (cursor.isNull(sendErrorColumnIndex)) null else cursor.getString(sendErrorColumnIndex)
+ val sendStateString = cursor.getStringOrThrow(COLUMN_SEND_STATE)
+ val numberOfSendAttempts = cursor.getIntOrThrow(COLUMN_NUMBER_OF_SEND_ATTEMPTS)
+ val sendErrorTimestamp = cursor.getLongOrThrow(COLUMN_ERROR_TIMESTAMP)
+ val sendError = cursor.getStringOrNull(COLUMN_ERROR)
val sendState = SendState.fromDatabaseName(sendStateString)
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
index 908699a8bbb67213e27bb538914719974c1a926e..e25f08c7767681e830fe2b62a4055102a78bb444 100644
--- a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
+++ b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
@@ -18,7 +18,7 @@ class SpecialFolderUpdater(
private val account: Account
) {
fun updateSpecialFolders() {
- val folders = folderRepository.getRemoteFolders()
+ val folders = folderRepository.getRemoteFolders(account)
updateInbox(folders)
@@ -42,15 +42,15 @@ class SpecialFolderUpdater(
account.inboxFolderId = newInboxId
if (oldInboxId != null && folders.any { it.id == oldInboxId }) {
- folderRepository.setIncludeInUnifiedInbox(oldInboxId, false)
+ folderRepository.setIncludeInUnifiedInbox(account, oldInboxId, false)
}
if (newInboxId != null) {
- folderRepository.setIncludeInUnifiedInbox(newInboxId, true)
- folderRepository.setDisplayClass(newInboxId, FolderClass.FIRST_CLASS)
- folderRepository.setSyncClass(newInboxId, FolderClass.FIRST_CLASS)
- folderRepository.setPushClass(newInboxId, FolderClass.FIRST_CLASS)
- folderRepository.setNotificationClass(newInboxId, FolderClass.FIRST_CLASS)
+ folderRepository.setIncludeInUnifiedInbox(account, newInboxId, true)
+ folderRepository.setDisplayClass(account, newInboxId, FolderClass.FIRST_CLASS)
+ folderRepository.setSyncClass(account, newInboxId, FolderClass.FIRST_CLASS)
+ folderRepository.setPushClass(account, newInboxId, FolderClass.FIRST_CLASS)
+ folderRepository.setNotificationClass(account, newInboxId, FolderClass.FIRST_CLASS)
}
}
@@ -117,8 +117,8 @@ class SpecialFolderUpdater(
}
if (folderId != null) {
- folderRepository.setDisplayClass(folderId, FolderClass.FIRST_CLASS)
- folderRepository.setSyncClass(folderId, FolderClass.NO_CLASS)
+ folderRepository.setDisplayClass(account, folderId, FolderClass.FIRST_CLASS)
+ folderRepository.setSyncClass(account, folderId, FolderClass.NO_CLASS)
}
}
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/StorageManager.java b/app/core/src/main/java/com/fsck/k9/mailstore/StorageManager.java
index 5e1ca29a19337ef6b4dc4eb7f9bc37455efec4bd..6aece52ec306c41a7142228f1f6e6ef5f45899ce 100644
--- a/app/core/src/main/java/com/fsck/k9/mailstore/StorageManager.java
+++ b/app/core/src/main/java/com/fsck/k9/mailstore/StorageManager.java
@@ -2,24 +2,15 @@ package com.fsck.k9.mailstore;
import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
import java.util.Arrays;
-import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.Set;
import android.content.Context;
import android.os.Environment;
-import com.fsck.k9.Core;
-import com.fsck.k9.CoreResourceProvider;
-import com.fsck.k9.DI;
-import timber.log.Timber;
/**
* Manager for different {@link StorageProvider} -classes that abstract access
@@ -64,14 +55,6 @@ public class StorageManager {
*/
void init(Context context);
- /**
- * @param context
- * Never null.
- * @return A user displayable, localized name for this provider. Never
- * null.
- */
- String getName(Context context);
-
/**
* Some implementations may not be able to return valid File handles
* because the device doesn't provide the denoted storage. You can check
@@ -110,135 +93,6 @@ public class StorageManager {
* @return Never null.
*/
File getAttachmentDirectory(Context context, String id);
-
- /**
- * Check for the underlying storage availability.
- *
- * @param context
- * Never null.
- * @return Whether the underlying storage returned by this provider is
- * ready for read/write operations at the time of invocation.
- */
- boolean isReady(Context context);
-
- /**
- * Retrieve the root of the underlying storage.
- *
- * @param context
- * Never null.
- * @return The root directory of the denoted storage. Never
- * null.
- */
- File getRoot(Context context);
- }
-
- /**
- * Interface for components wanting to be notified of storage availability
- * events.
- */
- public interface StorageListener {
- /**
- * Invoked on storage mount (with read/write access).
- *
- * @param providerId
- * Identifier (as returned by {@link StorageProvider#getId()}
- * of the newly mounted storage. Never null.
- */
- void onMount(String providerId);
-
- /**
- * Invoked when a storage is about to be unmounted.
- *
- * @param providerId
- * Identifier (as returned by {@link StorageProvider#getId()}
- * of the to-be-unmounted storage. Never null.
- */
- void onUnmount(String providerId);
- }
-
- /**
- * Base provider class for providers that rely on well-known path to check
- * for storage availability.
- *
- *
- * Since solely checking for paths can be unsafe, this class allows to check
- * for device compatibility using {@link #supportsVendor()}. If the vendor
- * specific check fails, the provider won't be able to provide any valid
- * File handle, regardless of the path existence.
- *
- *
- *
- * Moreover, this class validates the denoted storage path against mount
- * points using {@link StorageManager#isMountPoint(File)}.
- *
- */
- public abstract static class FixedStorageProviderBase implements StorageProvider {
- /**
- * The root of the denoted storage. Used for mount points checking.
- */
- private File mRoot;
-
- /**
- * Chosen base directory
- */
- private File mApplicationDir;
-
- @Override
- public void init(final Context context) {
- mRoot = computeRoot(context);
- // use /k9
- mApplicationDir = new File(mRoot, "k9");
- }
-
- /**
- * Vendor specific checks
- *
- * @return Whether this provider supports the underlying vendor specific
- * storage
- */
- protected abstract boolean supportsVendor();
-
- @Override
- public boolean isReady(Context context) {
- try {
- final File root = mRoot.getCanonicalFile();
- return isMountPoint(root)
- && Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
- } catch (IOException e) {
- Timber.w(e, "Specified root isn't ready: %s", mRoot);
- return false;
- }
- }
-
- @Override
- public final boolean isSupported(Context context) {
- return mRoot.isDirectory() && supportsVendor();
- }
-
- @Override
- public File getDatabase(Context context, String id) {
- return new File(mApplicationDir, id + ".db");
- }
-
- @Override
- public File getAttachmentDirectory(Context context, String id) {
- return new File(mApplicationDir, id + ".db_att");
- }
-
- @Override
- public final File getRoot(Context context) {
- return mRoot;
- }
-
- /**
- * Retrieve the well-known storage root directory from the actual
- * implementation.
- *
- * @param context
- * Never null.
- * @return Never null.
- */
- protected abstract File computeRoot(Context context);
}
/**
@@ -257,13 +111,6 @@ public class StorageManager {
public static class InternalStorageProvider implements StorageProvider {
public static final String ID = "InternalStorage";
- private final CoreResourceProvider resourceProvider;
- private File mRoot;
-
- public InternalStorageProvider(CoreResourceProvider resourceProvider) {
- this.resourceProvider = resourceProvider;
- }
-
@Override
public String getId() {
return ID;
@@ -271,13 +118,6 @@ public class StorageManager {
@Override
public void init(Context context) {
- // XXX
- mRoot = new File("/");
- }
-
- @Override
- public String getName(Context context) {
- return resourceProvider.internalStorageProviderName();
}
@Override
@@ -295,16 +135,6 @@ public class StorageManager {
// we store attachments in the database directory
return context.getDatabasePath(id + ".db_att");
}
-
- @Override
- public boolean isReady(Context context) {
- return true;
- }
-
- @Override
- public File getRoot(Context context) {
- return mRoot;
- }
}
/**
@@ -328,18 +158,12 @@ public class StorageManager {
public static class ExternalStorageProvider implements StorageProvider {
public static final String ID = "ExternalStorage";
- private final CoreResourceProvider resourceProvider;
-
/**
* Chosen base directory.
*/
private File mApplicationDirectory;
- public ExternalStorageProvider(CoreResourceProvider resourceProvider) {
- this.resourceProvider = resourceProvider;
- }
-
@Override
public String getId() {
return ID;
@@ -350,11 +174,6 @@ public class StorageManager {
mApplicationDirectory = context.getExternalFilesDir(null);
}
- @Override
- public String getName(Context context) {
- return resourceProvider.externalStorageProviderName();
- }
-
@Override
public boolean isSupported(Context context) {
return true;
@@ -369,37 +188,6 @@ public class StorageManager {
public File getAttachmentDirectory(Context context, String id) {
return new File(mApplicationDirectory, id + ".db_att");
}
-
- @Override
- public boolean isReady(Context context) {
- return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
- }
-
- @Override
- public File getRoot(Context context) {
- return Environment.getExternalStorageDirectory();
- }
- }
-
- /**
- * Stores storage provider locking information
- */
- public static class SynchronizationAid {
- /**
- * {@link Lock} has a thread semantic so it can't be released from
- * another thread - this flags act as a holder for the unmount state
- */
- public boolean unmounting = false;
-
- public final Lock readLock;
-
- public final Lock writeLock;
-
- {
- final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
- readLock = readWriteLock.readLock();
- writeLock = readWriteLock.writeLock();
- }
}
/**
@@ -407,51 +195,25 @@ public class StorageManager {
*/
private final Map mProviders = new LinkedHashMap<>();
- /**
- * Locking data for the active storage providers.
- */
- private final Map mProviderLocks = new IdentityHashMap<>();
-
protected final Context context;
- /**
- * Listener to be notified for storage related events.
- */
- private List mListeners = new ArrayList<>();
-
private static transient StorageManager instance;
public static synchronized StorageManager getInstance(final Context context) {
if (instance == null) {
Context applicationContext = context.getApplicationContext();
- CoreResourceProvider resourceProvider = DI.get(CoreResourceProvider.class);
- instance = new StorageManager(applicationContext, resourceProvider);
+ instance = new StorageManager(applicationContext);
}
return instance;
}
- /**
- * @param file
- * Canonical file to match. Never null.
- * @return Whether the specified file matches a filesystem root.
- * @throws IOException
- */
- public static boolean isMountPoint(final File file) {
- for (final File root : File.listRoots()) {
- if (root.equals(file)) {
- return true;
- }
- }
- return false;
- }
-
/**
* @param context
* Never null.
* @throws NullPointerException
* If context is null.
*/
- protected StorageManager(final Context context, CoreResourceProvider resourceProvider) throws NullPointerException {
+ protected StorageManager(final Context context) throws NullPointerException {
if (context == null) {
throw new NullPointerException("No Context given");
}
@@ -468,8 +230,9 @@ public class StorageManager {
* be considered as the default provider !!!
*/
final List allProviders = Arrays.asList(
- new InternalStorageProvider(resourceProvider),
- new ExternalStorageProvider(resourceProvider));
+ new InternalStorageProvider(),
+ new ExternalStorageProvider()
+ );
for (final StorageProvider provider : allProviders) {
// check for provider compatibility
if (provider.isSupported(context)) {
@@ -477,7 +240,6 @@ public class StorageManager {
provider.init(context);
mProviders.put(provider.getId(), provider);
- mProviderLocks.put(provider, new SynchronizationAid());
}
}
@@ -526,152 +288,7 @@ public class StorageManager {
return provider.getAttachmentDirectory(context, dbName);
}
- /**
- * @param providerId
- * Never null.
- * @return Whether the specified provider is ready for read/write operations
- */
- public boolean isReady(final String providerId) {
- StorageProvider provider = getProvider(providerId);
- if (provider == null) {
- Timber.w("Storage-Provider \"%s\" does not exist", providerId);
- return false;
- }
- return provider.isReady(context);
- }
-
- /**
- * @return A map of available providers names, indexed by their ID. Never
- * null.
- * @see StorageManager
- * @see StorageProvider#isSupported(Context)
- */
- public Map getAvailableProviders() {
- final Map result = new LinkedHashMap<>();
- for (final Map.Entry entry : mProviders.entrySet()) {
- result.put(entry.getKey(), entry.getValue().getName(context));
- }
- return result;
- }
-
- /**
- * @param path
- */
- public void onBeforeUnmount(final String path) {
- Timber.i("storage path \"%s\" unmounting", path);
- final StorageProvider provider = resolveProvider(path);
- if (provider == null) {
- return;
- }
- for (final StorageListener listener : mListeners) {
- try {
- listener.onUnmount(provider.getId());
- } catch (Exception e) {
- Timber.w(e, "Error while notifying StorageListener");
- }
- }
- final SynchronizationAid sync = mProviderLocks.get(resolveProvider(path));
- sync.writeLock.lock();
- sync.unmounting = true;
- sync.writeLock.unlock();
- }
-
- public void onAfterUnmount(final String path) {
- Timber.i("storage path \"%s\" unmounted", path);
- final StorageProvider provider = resolveProvider(path);
- if (provider == null) {
- return;
- }
- final SynchronizationAid sync = mProviderLocks.get(resolveProvider(path));
- sync.writeLock.lock();
- sync.unmounting = false;
- sync.writeLock.unlock();
-
- Core.setServicesEnabled(context);
- }
-
- /**
- * @param path
- * @param readOnly
- */
- public void onMount(final String path, final boolean readOnly) {
- Timber.i("storage path \"%s\" mounted readOnly=%s", path, readOnly);
- if (readOnly) {
- return;
- }
-
- final StorageProvider provider = resolveProvider(path);
- if (provider == null) {
- return;
- }
- for (final StorageListener listener : mListeners) {
- try {
- listener.onMount(provider.getId());
- } catch (Exception e) {
- Timber.w(e, "Error while notifying StorageListener");
- }
- }
-
- // XXX we should reset mail service ONLY if there are accounts using the storage (this is not done in a regular listener because it has to be invoked afterward)
- Core.setServicesEnabled(context);
- }
-
- /**
- * @param path
- * Never null.
- * @return The corresponding provider. null if no match.
- */
- protected StorageProvider resolveProvider(final String path) {
- for (final StorageProvider provider : mProviders.values()) {
- if (path.equals(provider.getRoot(context).getAbsolutePath())) {
- return provider;
- }
- }
- return null;
- }
-
- public void addListener(final StorageListener listener) {
- mListeners.add(listener);
- }
-
- public void removeListener(final StorageListener listener) {
- mListeners.remove(listener);
- }
-
- /**
- * Try to lock the underlying storage to prevent concurrent unmount.
- *
- *
- * You must invoke {@link #unlockProvider(String)} when you're done with the
- * storage.
- *
- *
- * @param providerId
- * @throws UnavailableStorageException
- * If the storage can't be locked.
- */
- public void lockProvider(final String providerId) throws UnavailableStorageException {
- final StorageProvider provider = getProvider(providerId);
- if (provider == null) {
- throw new UnavailableStorageException("StorageProvider not found: " + providerId);
- }
- // lock provider
- final SynchronizationAid sync = mProviderLocks.get(provider);
- final boolean locked = sync.readLock.tryLock();
- if (!locked || (locked && sync.unmounting)) {
- if (locked) {
- sync.readLock.unlock();
- }
- throw new UnavailableStorageException("StorageProvider is unmounting");
- } else if (locked && !provider.isReady(context)) {
- sync.readLock.unlock();
- throw new UnavailableStorageException("StorageProvider not ready");
- }
- }
-
- public void unlockProvider(final String providerId) {
- final StorageProvider provider = getProvider(providerId);
- final SynchronizationAid sync = mProviderLocks.get(provider);
- sync.readLock.unlock();
+ public Set getAvailableProviders() {
+ return mProviders.keySet();
}
}
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/UnavailableStorageException.java b/app/core/src/main/java/com/fsck/k9/mailstore/UnavailableStorageException.java
deleted file mode 100644
index 914add6e69d7ada7310340a2b4554372eb7d099c..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/mailstore/UnavailableStorageException.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.fsck.k9.mailstore;
-
-import com.fsck.k9.mail.MessagingException;
-
-public class UnavailableStorageException extends MessagingException {
-
- private static final long serialVersionUID = 1348267375054620792L;
-
- public UnavailableStorageException(String message) {
- // consider this exception as a permanent failure by default
- this(message, true);
- }
-
- public UnavailableStorageException(String message, boolean perm) {
- super(message, perm);
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/util/FlowedMessageUtils.java b/app/core/src/main/java/com/fsck/k9/mailstore/util/FlowedMessageUtils.java
deleted file mode 100644
index d30665a9251ce731d4cd3d735053a1a6aef8ffc7..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/mailstore/util/FlowedMessageUtils.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package com.fsck.k9.mailstore.util;
-
-
-/**
- * Adapted from the Apache James project, see
- * https://james.apache.org/mailet/base/apidocs/org/apache/mailet/base/FlowedMessageUtils.html
- *
- * Manages texts encoded as text/plain; format=flowed.
- * As a reference see:
- *
- * Note
- *
- * - In order to decode, the input text must belong to a mail with headers similar to:
- * Content-Type: text/plain; charset="CHARSET"; [delsp="yes|no"; ]format="flowed"
- * (the quotes around CHARSET are not mandatory).
- * Furthermore the header Content-Transfer-Encoding MUST NOT BE Quoted-Printable
- * (see RFC3676 paragraph 4.2).(In fact this happens often for non 7bit messages).
- *
- *
- */
-public final class FlowedMessageUtils {
- private static final char RFC2646_SPACE = ' ';
- private static final char RFC2646_QUOTE = '>';
- private static final String RFC2646_SIGNATURE = "-- ";
- private static final String RFC2646_CRLF = "\r\n";
-
- private FlowedMessageUtils() {
- // this class cannot be instantiated
- }
-
- /**
- * Decodes a text previously wrapped using "format=flowed".
- */
- public static String deflow(String text, boolean delSp) {
- String[] lines = text.split("\r\n|\n", -1);
- StringBuffer result = null;
- StringBuffer resultLine = new StringBuffer();
- int resultLineQuoteDepth = 0;
- boolean resultLineFlowed = false;
- // One more cycle, to close the last line
- for (int i = 0; i <= lines.length; i++) {
- String line = i < lines.length ? lines[i] : null;
- int actualQuoteDepth = 0;
-
- if (line != null && line.length() > 0) {
- if (line.equals(RFC2646_SIGNATURE))
- // signature handling (the previous line is not flowed)
- resultLineFlowed = false;
-
- else if (line.charAt(0) == RFC2646_QUOTE) {
- // Quote
- actualQuoteDepth = 1;
- while (actualQuoteDepth < line.length() && line.charAt(actualQuoteDepth) == RFC2646_QUOTE) actualQuoteDepth ++;
- // if quote-depth changes wrt the previous line then this is not flowed
- if (resultLineQuoteDepth != actualQuoteDepth) resultLineFlowed = false;
- line = line.substring(actualQuoteDepth);
-
- } else {
- // id quote-depth changes wrt the first line then this is not flowed
- if (resultLineQuoteDepth > 0) resultLineFlowed = false;
- }
-
- if (line.length() > 0 && line.charAt(0) == RFC2646_SPACE)
- // Line space-stuffed
- line = line.substring(1);
-
- // if the previous was the last then it was not flowed
- } else if (line == null) resultLineFlowed = false;
-
- // Add the PREVIOUS line.
- // This often will find the flow looking for a space as the last char of the line.
- // With quote changes or signatures it could be the followinf line to void the flow.
- if (!resultLineFlowed && i > 0) {
- if (resultLineQuoteDepth > 0) resultLine.insert(0, RFC2646_SPACE);
- for (int j = 0; j < resultLineQuoteDepth; j++) resultLine.insert(0, RFC2646_QUOTE);
- if (result == null) result = new StringBuffer();
- else result.append(RFC2646_CRLF);
- result.append(resultLine.toString());
- resultLine = new StringBuffer();
- resultLineFlowed = false;
- }
- resultLineQuoteDepth = actualQuoteDepth;
-
- if (line != null) {
- if (!line.equals(RFC2646_SIGNATURE) && line.endsWith("" + RFC2646_SPACE) && i < lines.length - 1) {
- // Line flowed (NOTE: for the split operation the line having i == lines.length is the last that does not end with RFC2646_CRLF)
- if (delSp) line = line.substring(0, line.length() - 1);
- resultLineFlowed = true;
- }
-
- else resultLineFlowed = false;
-
- resultLine.append(line);
- }
- }
-
- return result.toString();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
index 51eca9da5bd059c91a4a265daa6c0763fbc826da..cb6c2c2344893a694604ba4f19025b07dbfc360a 100644
--- a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
+++ b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
@@ -3,16 +3,20 @@ package com.fsck.k9.message;
import android.net.Uri;
import android.net.Uri.Builder;
-import timber.log.Timber;
import com.fsck.k9.Account.QuoteStyle;
import com.fsck.k9.Identity;
+import com.fsck.k9.K9;
import com.fsck.k9.controller.MessageReference;
import com.fsck.k9.mail.internet.TextBody;
import com.fsck.k9.message.quote.InsertableHtmlContent;
+import timber.log.Timber;
public class IdentityHeaderBuilder {
+ private static final int MAX_LINE_LENGTH = 72;
+ private static final int FIRST_LINE_EXTRA_LENGTH = K9.IDENTITY_HEADER.length() + 2;
+
private InsertableHtmlContent quotedHtmlContent;
private QuoteStyle quoteStyle;
private SimpleMessageFormat messageFormat;
@@ -95,9 +99,33 @@ public class IdentityHeaderBuilder {
appendValue(IdentityField.QUOTED_TEXT_MODE, quotedTextMode);
String k9identity = IdentityField.IDENTITY_VERSION_1 + uri.build().getEncodedQuery();
+ String headerValue = foldHeaderValue(k9identity);
+
+ Timber.d("Generated identity: %s", headerValue);
+ return headerValue;
+ }
+
+ private String foldHeaderValue(String input) {
+ int inputLength = input.length();
+ int endOfFirstLine = MAX_LINE_LENGTH - FIRST_LINE_EXTRA_LENGTH;
+ if (inputLength <= endOfFirstLine) {
+ return input;
+ }
+
+ int extraLines = (inputLength - endOfFirstLine - 1) / (MAX_LINE_LENGTH - 1) + 1;
+ int builderSize = inputLength + extraLines * 3 /* CR LF SPACE */;
+ StringBuilder headerValue = new StringBuilder(builderSize);
+
+ headerValue.append(input, 0, endOfFirstLine);
+ int start = endOfFirstLine;
+ while (start < inputLength) {
+ headerValue.append("\r\n ");
+ int end = start + Math.min(MAX_LINE_LENGTH - 1, inputLength - start);
+ headerValue.append(input, start, end);
+ start = end;
+ }
- Timber.d("Generated identity: %s", k9identity);
- return k9identity;
+ return headerValue.toString();
}
private void appendValue(IdentityField field, int value) {
diff --git a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderParser.java b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderParser.java
index e73cea944de41cee98ddf8b84b3a35639860724a..14b97add02bb686523ae69f39ee46778f0d7df93 100644
--- a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderParser.java
+++ b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderParser.java
@@ -29,10 +29,12 @@ public class IdentityHeaderParser {
return identity;
}
+ String encodedString = unfoldHeaderValue(identityString);
+
// Check to see if this is a "next gen" identity.
- if (identityString.charAt(0) == IdentityField.IDENTITY_VERSION_1.charAt(0) && identityString.length() > 2) {
+ if (encodedString.charAt(0) == IdentityField.IDENTITY_VERSION_1.charAt(0) && encodedString.length() > 2) {
Uri.Builder builder = new Uri.Builder();
- builder.encodedQuery(identityString.substring(1)); // Need to cut off the ! at the beginning.
+ builder.encodedQuery(encodedString.substring(1)); // Need to cut off the ! at the beginning.
Uri uri = builder.build();
for (IdentityField key : IdentityField.values()) {
String value = uri.getQueryParameter(key.value());
@@ -56,9 +58,9 @@ public class IdentityHeaderParser {
} else {
// Legacy identity
- Timber.d("Got a saved legacy identity: %s", identityString);
+ Timber.d("Got a saved legacy identity: %s", encodedString);
- StringTokenizer tokenizer = new StringTokenizer(identityString, ":", false);
+ StringTokenizer tokenizer = new StringTokenizer(encodedString, ":", false);
// First item is the body length. We use this to separate the composed reply from the quoted text.
if (tokenizer.hasMoreTokens()) {
@@ -85,4 +87,8 @@ public class IdentityHeaderParser {
return identity;
}
+
+ private static String unfoldHeaderValue(String identityString) {
+ return identityString.replaceAll("\r?\n ", "");
+ }
}
diff --git a/app/core/src/main/java/com/fsck/k9/message/MessageBuilder.java b/app/core/src/main/java/com/fsck/k9/message/MessageBuilder.java
index 8ea190b154ef59350523fef7600bf269153a1b5f..0df05d2c8ec491de36943c47c769365a94e38f07 100644
--- a/app/core/src/main/java/com/fsck/k9/message/MessageBuilder.java
+++ b/app/core/src/main/java/com/fsck/k9/message/MessageBuilder.java
@@ -50,6 +50,7 @@ public abstract class MessageBuilder {
private Address[] to;
private Address[] cc;
private Address[] bcc;
+ private Address[] replyTo;
private String inReplyTo;
private String references;
private boolean requestReadReceipt;
@@ -115,10 +116,7 @@ public abstract class MessageBuilder {
message.setHeader("User-Agent", encodedUserAgent);
}
- final String replyTo = identity.getReplyTo();
- if (replyTo != null) {
- message.setReplyTo(new Address[] { new Address(replyTo) });
- }
+ message.setReplyTo(replyTo);
if (inReplyTo != null) {
message.setInReplyTo(inReplyTo);
@@ -395,6 +393,11 @@ public abstract class MessageBuilder {
return this;
}
+ public MessageBuilder setReplyTo(Address[] replyTo) {
+ this.replyTo = replyTo;
+ return this;
+ }
+
public MessageBuilder setInReplyTo(String inReplyTo) {
this.inReplyTo = inReplyTo;
return this;
diff --git a/app/core/src/main/java/com/fsck/k9/message/extractors/BasicPartInfoExtractor.kt b/app/core/src/main/java/com/fsck/k9/message/extractors/BasicPartInfoExtractor.kt
index b571abece8dd17612a542f997e462679e9f941ed..6992a87a4a1bd344786e1e913afb5fd74f76f898 100644
--- a/app/core/src/main/java/com/fsck/k9/message/extractors/BasicPartInfoExtractor.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/extractors/BasicPartInfoExtractor.kt
@@ -4,7 +4,6 @@ import com.fsck.k9.mail.Part
import com.fsck.k9.mail.internet.MimeParameterDecoder
import com.fsck.k9.mail.internet.MimeUtility
import com.fsck.k9.mail.internet.MimeValue
-import java.util.Locale
private const val FALLBACK_NAME = "noname"
@@ -38,11 +37,11 @@ class BasicPartInfoExtractor {
private fun String.toMimeValue(): MimeValue = MimeParameterDecoder.decode(this)
- private fun MimeValue.getParameter(name: String): String? = parameters[name.toLowerCase(Locale.ROOT)]
+ private fun MimeValue.getParameter(name: String): String? = parameters[name.lowercase()]
private fun String.getParameter(name: String): String? {
val mimeValue = MimeParameterDecoder.decode(this)
- return mimeValue.parameters[name.toLowerCase(Locale.ROOT)]
+ return mimeValue.parameters[name.lowercase()]
}
}
diff --git a/app/core/src/main/java/com/fsck/k9/message/html/HtmlToPlainText.kt b/app/core/src/main/java/com/fsck/k9/message/html/HtmlToPlainText.kt
index 191270718c05c1cb2520e76985861ba88b8900fb..9ea06eafe74b8c8152699a19d0ec6144bc15820d 100644
--- a/app/core/src/main/java/com/fsck/k9/message/html/HtmlToPlainText.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/html/HtmlToPlainText.kt
@@ -22,7 +22,6 @@ object HtmlToPlainText {
}
private class FormattingVisitor : NodeVisitor {
- private var width = 0
private val output = StringBuilder()
private var collectLinkText = false
private var linkText = StringBuilder()
@@ -73,36 +72,11 @@ private class FormattingVisitor : NodeVisitor {
}
private fun append(text: String) {
- if (text.startsWith("\n")) {
- width = 0
- }
-
if (text == " " && (output.isEmpty() || output.last() in listOf(' ', '\n'))) {
return
}
- if (text.length + width > MAX_WIDTH) {
- val words = text.split(Regex("\\s+"))
- for (i in words.indices) {
- var word = words[i]
-
- val last = i == words.size - 1
- if (!last) {
- word = "$word "
- }
-
- if (word.length + width > MAX_WIDTH) {
- output.append("\n").append(word)
- width = word.length
- } else {
- output.append(word)
- width += word.length
- }
- }
- } else {
- output.append(text)
- width += text.length
- }
+ output.append(text)
}
private fun startNewLine() {
@@ -134,8 +108,4 @@ private class FormattingVisitor : NodeVisitor {
return output.substring(0, lastIndex + 1)
}
-
- companion object {
- private const val MAX_WIDTH = 76
- }
}
diff --git a/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt b/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
index ee5b44344d3191b2e19b5ef45143b01b1c22c8b8..5dea02560e4928e60caeffd8a5930f8d3755fbc6 100644
--- a/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
@@ -1,9 +1,8 @@
package com.fsck.k9.message.html
-import java.util.Locale
-
object UriMatcher {
- private val SUPPORTED_URIS = { httpUriParser: HttpUriParser ->
+ private val SUPPORTED_URIS = run {
+ val httpUriParser = HttpUriParser()
mapOf(
"ethereum:" to EthereumUriParser(),
"bitcoin:" to BitcoinUriParser(),
@@ -11,7 +10,7 @@ object UriMatcher {
"https:" to httpUriParser,
"rtsp:" to httpUriParser
)
- }.invoke(HttpUriParser())
+ }
private const val SCHEME_SEPARATORS = "\\s(\\n<"
private const val ALLOWED_SEPARATORS_PATTERN = "(?:^|[$SCHEME_SEPARATORS])"
@@ -23,8 +22,8 @@ object UriMatcher {
fun findUris(text: CharSequence): List {
return URI_SCHEME.findAll(text).map { matchResult ->
val matchGroup = matchResult.groups[1]!!
- val startIndex = matchGroup.range.start
- val scheme = matchGroup.value.toLowerCase(Locale.ROOT)
+ val startIndex = matchGroup.range.first
+ val scheme = matchGroup.value.lowercase()
val parser = SUPPORTED_URIS[scheme] ?: throw AssertionError("Scheme not found: $scheme")
parser.parseUri(text, startIndex)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.java b/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.java
deleted file mode 100644
index 9dd3257fa1a025497a71cddda1fa9a5370c332db..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.fsck.k9.notification;
-
-
-class AddNotificationResult {
- private final NotificationHolder notificationHolder;
- private final boolean cancelNotificationBeforeReuse;
-
-
- private AddNotificationResult(NotificationHolder notificationHolder,
- boolean cancelNotificationBeforeReuse) {
- this.notificationHolder = notificationHolder;
- this.cancelNotificationBeforeReuse = cancelNotificationBeforeReuse;
- }
-
- public static AddNotificationResult newNotification(NotificationHolder notificationHolder) {
- return new AddNotificationResult(notificationHolder, false);
- }
-
- public static AddNotificationResult replaceNotification(NotificationHolder notificationHolder) {
- return new AddNotificationResult(notificationHolder, true);
- }
-
- public boolean shouldCancelNotification() {
- return cancelNotificationBeforeReuse;
- }
-
- public int getNotificationId() {
- if (!shouldCancelNotification()) {
- throw new IllegalStateException("getNotificationId() can only be called when " +
- "shouldCancelNotification() returns true");
- }
-
- return notificationHolder.notificationId;
- }
-
- public NotificationHolder getNotificationHolder() {
- return notificationHolder;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.kt b/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..662235eb2f9714bd308c58eab09b0a426f15992a
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/AddNotificationResult.kt
@@ -0,0 +1,42 @@
+package com.fsck.k9.notification
+
+internal class AddNotificationResult private constructor(
+ val notificationData: NotificationData,
+ val notificationStoreOperations: List,
+ val notificationHolder: NotificationHolder,
+ val shouldCancelNotification: Boolean
+) {
+ val cancelNotificationId: Int
+ get() {
+ check(shouldCancelNotification) { "shouldCancelNotification == false" }
+ return notificationHolder.notificationId
+ }
+
+ companion object {
+ fun newNotification(
+ notificationData: NotificationData,
+ notificationStoreOperations: List,
+ notificationHolder: NotificationHolder
+ ): AddNotificationResult {
+ return AddNotificationResult(
+ notificationData,
+ notificationStoreOperations,
+ notificationHolder,
+ shouldCancelNotification = false
+ )
+ }
+
+ fun replaceNotification(
+ notificationData: NotificationData,
+ notificationStoreOperations: List,
+ notificationHolder: NotificationHolder
+ ): AddNotificationResult {
+ return AddNotificationResult(
+ notificationData,
+ notificationStoreOperations,
+ notificationHolder,
+ shouldCancelNotification = true
+ )
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fad5368c95f9e1e9a72b5a6465592653274fed70
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotificationController.kt
@@ -0,0 +1,71 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+import android.app.PendingIntent
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.Account
+
+internal open class AuthenticationErrorNotificationController(
+ private val notificationHelper: NotificationHelper,
+ private val actionCreator: NotificationActionCreator,
+ private val resourceProvider: NotificationResourceProvider
+) {
+ fun showAuthenticationErrorNotification(account: Account, incoming: Boolean) {
+ val notificationId = NotificationIds.getAuthenticationErrorNotificationId(account, incoming)
+ val editServerSettingsPendingIntent = createContentIntent(account, incoming)
+ val title = resourceProvider.authenticationErrorTitle()
+ val text = resourceProvider.authenticationErrorBody(account.description)
+
+ val notificationBuilder = notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setAutoCancel(true)
+ .setTicker(title)
+ .setContentTitle(title)
+ .setContentText(text)
+ .setContentIntent(editServerSettingsPendingIntent)
+ .setStyle(NotificationCompat.BigTextStyle().bigText(text))
+ .setPublicVersion(createLockScreenNotification(account))
+ .setCategory(NotificationCompat.CATEGORY_ERROR)
+
+ notificationHelper.configureNotification(
+ builder = notificationBuilder,
+ ringtone = null,
+ vibrationPattern = null,
+ ledColor = NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR,
+ ledSpeed = NotificationHelper.NOTIFICATION_LED_BLINK_FAST,
+ ringAndVibrate = true
+ )
+
+ notificationManager.notify(notificationId, notificationBuilder.build())
+ }
+
+ fun clearAuthenticationErrorNotification(account: Account, incoming: Boolean) {
+ val notificationId = NotificationIds.getAuthenticationErrorNotificationId(account, incoming)
+ notificationManager.cancel(notificationId)
+ }
+
+ protected open fun createContentIntent(account: Account, incoming: Boolean): PendingIntent {
+ return if (incoming) {
+ actionCreator.getEditIncomingServerSettingsIntent(account)
+ } else {
+ actionCreator.getEditOutgoingServerSettingsIntent(account)
+ }
+ }
+
+ private fun createLockScreenNotification(account: Account): Notification {
+ return notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setContentTitle(resourceProvider.authenticationErrorTitle())
+ .build()
+ }
+
+ private val notificationManager: NotificationManagerCompat
+ get() = notificationHelper.getNotificationManager()
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotifications.java
deleted file mode 100644
index 302199d4da6f021ebc595f5c0d0fc50746addca5..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/AuthenticationErrorNotifications.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.app.PendingIntent;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.BigTextStyle;
-import androidx.core.app.NotificationManagerCompat;
-
-import com.fsck.k9.Account;
-
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_BLINK_FAST;
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR;
-
-
-class AuthenticationErrorNotifications {
- private final NotificationHelper notificationHelper;
- private final NotificationActionCreator actionCreator;
- private final NotificationResourceProvider resourceProvider;
-
-
- public AuthenticationErrorNotifications(NotificationHelper notificationHelper,
- NotificationActionCreator actionCreator, NotificationResourceProvider resourceProvider) {
- this.notificationHelper = notificationHelper;
- this.actionCreator = actionCreator;
- this.resourceProvider = resourceProvider;
- }
-
- public void showAuthenticationErrorNotification(Account account, boolean incoming) {
- int notificationId = NotificationIds.getAuthenticationErrorNotificationId(account, incoming);
-
- PendingIntent editServerSettingsPendingIntent = createContentIntent(account, incoming);
- String title = resourceProvider.authenticationErrorTitle();
- String text = resourceProvider.authenticationErrorBody(account.getDescription());
-
- NotificationCompat.Builder builder = notificationHelper
- .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
- .setSmallIcon(resourceProvider.getIconWarning())
- .setWhen(System.currentTimeMillis())
- .setAutoCancel(true)
- .setTicker(title)
- .setContentTitle(title)
- .setContentText(text)
- .setContentIntent(editServerSettingsPendingIntent)
- .setStyle(new BigTextStyle().bigText(text))
- .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
- .setCategory(NotificationCompat.CATEGORY_ERROR);
-
- notificationHelper.configureNotification(builder, null, null,
- NOTIFICATION_LED_FAILURE_COLOR,
- NOTIFICATION_LED_BLINK_FAST, true);
-
- getNotificationManager().notify(notificationId, builder.build());
- }
-
- public void clearAuthenticationErrorNotification(Account account, boolean incoming) {
- int notificationId = NotificationIds.getAuthenticationErrorNotificationId(account, incoming);
- getNotificationManager().cancel(notificationId);
- }
-
- PendingIntent createContentIntent(Account account, boolean incoming) {
- return incoming ? actionCreator.getEditIncomingServerSettingsIntent(account) :
- actionCreator.getEditOutgoingServerSettingsIntent(account);
- }
-
- private NotificationManagerCompat getNotificationManager() {
- return notificationHelper.getNotificationManager();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/BaseNotificationDataCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/BaseNotificationDataCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..936f884c4dd10dee9d0a579e8b1d13e3e890412e
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/BaseNotificationDataCreator.kt
@@ -0,0 +1,53 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.K9
+import com.fsck.k9.K9.LockScreenNotificationVisibility
+
+private const val MAX_NUMBER_OF_SENDERS_IN_LOCK_SCREEN_NOTIFICATION = 5
+
+internal class BaseNotificationDataCreator {
+
+ fun createBaseNotificationData(notificationData: NotificationData): BaseNotificationData {
+ val account = notificationData.account
+ return BaseNotificationData(
+ account = account,
+ groupKey = NotificationGroupKeys.getGroupKey(account),
+ accountName = getAccountName(account),
+ color = account.chipColor,
+ newMessagesCount = notificationData.newMessagesCount,
+ lockScreenNotificationData = createLockScreenNotificationData(notificationData),
+ appearance = createNotificationAppearance(account)
+ )
+ }
+
+ private fun getAccountName(account: Account): String {
+ val accountDescription = account.description?.takeIf { it.isNotEmpty() }
+ return accountDescription ?: account.email
+ }
+
+ private fun createLockScreenNotificationData(data: NotificationData): LockScreenNotificationData {
+ return when (K9.lockScreenNotificationVisibility) {
+ LockScreenNotificationVisibility.NOTHING -> LockScreenNotificationData.None
+ LockScreenNotificationVisibility.APP_NAME -> LockScreenNotificationData.AppName
+ LockScreenNotificationVisibility.EVERYTHING -> LockScreenNotificationData.Public
+ LockScreenNotificationVisibility.MESSAGE_COUNT -> LockScreenNotificationData.MessageCount
+ LockScreenNotificationVisibility.SENDERS -> LockScreenNotificationData.SenderNames(getSenderNames(data))
+ }
+ }
+
+ private fun getSenderNames(data: NotificationData): String {
+ return data.activeNotifications.asSequence()
+ .map { it.content.sender }
+ .distinct()
+ .take(MAX_NUMBER_OF_SENDERS_IN_LOCK_SCREEN_NOTIFICATION)
+ .joinToString()
+ }
+
+ private fun createNotificationAppearance(account: Account): NotificationAppearance {
+ return with(account.notificationSetting) {
+ val vibrationPattern = if (isVibrateEnabled) vibration else null
+ NotificationAppearance(ringtone, vibrationPattern, ledColor)
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/BaseNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/BaseNotifications.java
deleted file mode 100644
index 5534372de0085aaf11e07894dc1671764cd04007..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/BaseNotifications.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.app.PendingIntent;
-import android.content.Context;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.BigTextStyle;
-import androidx.core.app.NotificationCompat.Builder;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-import com.fsck.k9.K9.NotificationQuickDelete;
-
-
-abstract class BaseNotifications {
- protected final Context context;
- protected final NotificationHelper notificationHelper;
- protected final NotificationActionCreator actionCreator;
- protected final NotificationResourceProvider resourceProvider;
-
-
- protected BaseNotifications(NotificationHelper notificationHelper, NotificationActionCreator actionCreator,
- NotificationResourceProvider resourceProvider) {
- this.context = notificationHelper.getContext();
- this.notificationHelper = notificationHelper;
- this.actionCreator = actionCreator;
- this.resourceProvider = resourceProvider;
- }
-
- protected NotificationCompat.Builder createBigTextStyleNotification(Account account, NotificationHolder holder,
- int notificationId) {
- String accountName = notificationHelper.getAccountName(account);
- NotificationContent content = holder.content;
- String groupKey = NotificationGroupKeys.getGroupKey(account);
-
- NotificationCompat.Builder builder = createAndInitializeNotificationBuilder(account)
- .setTicker(content.summary)
- .setGroup(groupKey)
- .setContentTitle(content.sender)
- .setContentText(content.subject)
- .setSubText(accountName);
-
- NotificationCompat.BigTextStyle style = createBigTextStyle(builder);
- style.bigText(content.preview);
-
- builder.setStyle(style);
-
- PendingIntent contentIntent = actionCreator.createViewMessagePendingIntent(
- content.messageReference, notificationId);
- builder.setContentIntent(contentIntent);
-
- return builder;
- }
-
- protected NotificationCompat.Builder createAndInitializeNotificationBuilder(Account account) {
- return notificationHelper.createNotificationBuilder(account,
- NotificationChannelManager.ChannelType.MESSAGES)
- .setSmallIcon(getNewMailNotificationIcon())
- .setColor(account.getChipColor())
- .setWhen(System.currentTimeMillis())
- .setAutoCancel(true)
- .setCategory(NotificationCompat.CATEGORY_EMAIL);
- }
-
- protected boolean isDeleteActionEnabled() {
- NotificationQuickDelete deleteOption = K9.getNotificationQuickDeleteBehaviour();
- return deleteOption == NotificationQuickDelete.ALWAYS || deleteOption == NotificationQuickDelete.FOR_SINGLE_MSG;
- }
-
- protected BigTextStyle createBigTextStyle(Builder builder) {
- return new BigTextStyle(builder);
- }
-
- private int getNewMailNotificationIcon() {
- return resourceProvider.getIconNewMail();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e787b85efbaa09c9ec7da7424dc48438599b138b
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotificationController.kt
@@ -0,0 +1,71 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+import android.app.PendingIntent
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.Account
+
+internal open class CertificateErrorNotificationController(
+ private val notificationHelper: NotificationHelper,
+ private val actionCreator: NotificationActionCreator,
+ private val resourceProvider: NotificationResourceProvider
+) {
+ fun showCertificateErrorNotification(account: Account, incoming: Boolean) {
+ val notificationId = NotificationIds.getCertificateErrorNotificationId(account, incoming)
+ val editServerSettingsPendingIntent = createContentIntent(account, incoming)
+ val title = resourceProvider.certificateErrorTitle(account.description)
+ val text = resourceProvider.certificateErrorBody()
+
+ val notificationBuilder = notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setAutoCancel(true)
+ .setTicker(title)
+ .setContentTitle(title)
+ .setContentText(text)
+ .setContentIntent(editServerSettingsPendingIntent)
+ .setStyle(NotificationCompat.BigTextStyle().bigText(text))
+ .setPublicVersion(createLockScreenNotification(account))
+ .setCategory(NotificationCompat.CATEGORY_ERROR)
+
+ notificationHelper.configureNotification(
+ builder = notificationBuilder,
+ ringtone = null,
+ vibrationPattern = null,
+ ledColor = NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR,
+ ledSpeed = NotificationHelper.NOTIFICATION_LED_BLINK_FAST,
+ ringAndVibrate = true
+ )
+
+ notificationManager.notify(notificationId, notificationBuilder.build())
+ }
+
+ fun clearCertificateErrorNotifications(account: Account, incoming: Boolean) {
+ val notificationId = NotificationIds.getCertificateErrorNotificationId(account, incoming)
+ notificationManager.cancel(notificationId)
+ }
+
+ protected open fun createContentIntent(account: Account, incoming: Boolean): PendingIntent {
+ return if (incoming) {
+ actionCreator.getEditIncomingServerSettingsIntent(account)
+ } else {
+ actionCreator.getEditOutgoingServerSettingsIntent(account)
+ }
+ }
+
+ private fun createLockScreenNotification(account: Account): Notification {
+ return notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setContentTitle(resourceProvider.certificateErrorTitle())
+ .build()
+ }
+
+ private val notificationManager: NotificationManagerCompat
+ get() = notificationHelper.getNotificationManager()
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotifications.java
deleted file mode 100644
index a5239b1634abfc8f311048c0ad162083ef344243..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/CertificateErrorNotifications.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.app.PendingIntent;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.BigTextStyle;
-import androidx.core.app.NotificationManagerCompat;
-
-import com.fsck.k9.Account;
-
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_BLINK_FAST;
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR;
-
-
-class CertificateErrorNotifications {
- private final NotificationHelper notificationHelper;
- private final NotificationActionCreator actionCreator;
- private final NotificationResourceProvider resourceProvider;
-
-
- public CertificateErrorNotifications(NotificationHelper notificationHelper,
- NotificationActionCreator actionCreator, NotificationResourceProvider resourceProvider) {
- this.notificationHelper = notificationHelper;
- this.actionCreator = actionCreator;
- this.resourceProvider = resourceProvider;
- }
-
- public void showCertificateErrorNotification(Account account, boolean incoming) {
- int notificationId = NotificationIds.getCertificateErrorNotificationId(account, incoming);
-
- PendingIntent editServerSettingsPendingIntent = createContentIntent(account, incoming);
- String title = resourceProvider.certificateErrorTitle(account.getDescription());
- String text = resourceProvider.certificateErrorBody();
-
- NotificationCompat.Builder builder = notificationHelper
- .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
- .setSmallIcon(resourceProvider.getIconWarning())
- .setWhen(System.currentTimeMillis())
- .setAutoCancel(true)
- .setTicker(title)
- .setContentTitle(title)
- .setContentText(text)
- .setContentIntent(editServerSettingsPendingIntent)
- .setStyle(new BigTextStyle().bigText(text))
- .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
- .setCategory(NotificationCompat.CATEGORY_ERROR);
-
- notificationHelper.configureNotification(builder, null, null,
- NOTIFICATION_LED_FAILURE_COLOR,
- NOTIFICATION_LED_BLINK_FAST, true);
-
- getNotificationManager().notify(notificationId, builder.build());
- }
-
- public void clearCertificateErrorNotifications(Account account, boolean incoming) {
- int notificationId = NotificationIds.getCertificateErrorNotificationId(account, incoming);
- getNotificationManager().cancel(notificationId);
- }
-
- PendingIntent createContentIntent(Account account, boolean incoming) {
- return incoming ?
- actionCreator.getEditIncomingServerSettingsIntent(account) :
- actionCreator.getEditOutgoingServerSettingsIntent(account);
- }
-
- private NotificationManagerCompat getNotificationManager() {
- return notificationHelper.getNotificationManager();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt b/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
index 6904c91255921af2b0857da4dc647a9d04091690..dba15df01c6a5cf718223dd1e12c7479fe2227bf 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
@@ -8,15 +8,23 @@ import java.util.concurrent.Executors
import org.koin.dsl.module
val coreNotificationModule = module {
- single { NotificationController(get(), get(), get(), get(), get()) }
+ single {
+ NotificationController(
+ certificateErrorNotificationController = get(),
+ authenticationErrorNotificationController = get(),
+ syncNotificationController = get(),
+ sendFailedNotificationController = get(),
+ newMailNotificationController = get()
+ )
+ }
single { NotificationManagerCompat.from(get()) }
- single { NotificationHelper(get(), get(), get()) }
+ single { NotificationHelper(context = get(), notificationManager = get(), channelUtils = get()) }
single {
NotificationChannelManager(
- get(),
- Executors.newSingleThreadExecutor(),
- get().getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager,
- get()
+ preferences = get(),
+ backgroundExecutor = Executors.newSingleThreadExecutor(),
+ notificationManager = get().getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager,
+ resourceProvider = get()
)
}
single {
@@ -26,15 +34,68 @@ val coreNotificationModule = module {
serverSettingsSerializer = get()
)
}
- single { CertificateErrorNotifications(get(), get(), get()) }
- single { AuthenticationErrorNotifications(get(), get(), get()) }
- single { SyncNotifications(get(), get(), get()) }
- single { SendFailedNotifications(get(), get(), get()) }
- single { NewMailNotifications(get(), get(), get(), get()) }
- single { NotificationContentCreator(get(), get()) }
- single { WearNotifications(get(), get(), get()) }
- single { DeviceNotifications(get(), get(), get(), get(), get()) }
- single { LockScreenNotification(get(), get()) }
+ single {
+ CertificateErrorNotificationController(
+ notificationHelper = get(),
+ actionCreator = get(),
+ resourceProvider = get()
+ )
+ }
+ single {
+ AuthenticationErrorNotificationController(
+ notificationHelper = get(),
+ actionCreator = get(),
+ resourceProvider = get()
+ )
+ }
+ single {
+ SyncNotificationController(notificationHelper = get(), actionBuilder = get(), resourceProvider = get())
+ }
+ single {
+ SendFailedNotificationController(notificationHelper = get(), actionBuilder = get(), resourceProvider = get())
+ }
+ single {
+ NewMailNotificationController(
+ notificationManager = get(),
+ newMailNotificationManager = get(),
+ summaryNotificationCreator = get(),
+ singleMessageNotificationCreator = get()
+ )
+ }
+ single {
+ NewMailNotificationManager(
+ contentCreator = get(),
+ notificationRepository = get(),
+ baseNotificationDataCreator = get(),
+ singleMessageNotificationDataCreator = get(),
+ summaryNotificationDataCreator = get(),
+ clock = get()
+ )
+ }
+ factory { NotificationContentCreator(context = get(), resourceProvider = get()) }
+ factory { BaseNotificationDataCreator() }
+ factory { SingleMessageNotificationDataCreator() }
+ factory { SummaryNotificationDataCreator(singleMessageNotificationDataCreator = get()) }
+ factory {
+ SingleMessageNotificationCreator(
+ notificationHelper = get(),
+ actionCreator = get(),
+ resourceProvider = get(),
+ lockScreenNotificationCreator = get(),
+ notificationManager = get()
+ )
+ }
+ factory {
+ SummaryNotificationCreator(
+ notificationHelper = get(),
+ actionCreator = get(),
+ lockScreenNotificationCreator = get(),
+ singleMessageNotificationCreator = get(),
+ resourceProvider = get(),
+ notificationManager = get()
+ )
+ }
+ factory { LockScreenNotificationCreator(notificationHelper = get(), resourceProvider = get()) }
single {
PushNotificationManager(
context = get(),
@@ -43,4 +104,12 @@ val coreNotificationModule = module {
notificationManager = get()
)
}
+ single {
+ NotificationRepository(
+ notificationStoreProvider = get(),
+ localStoreProvider = get(),
+ messageStoreManager = get(),
+ notificationContentCreator = get()
+ )
+ }
}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/DeviceNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/DeviceNotifications.java
deleted file mode 100644
index d9b7af54b01e33e2193c4eb287c66b03d84ba5a7..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/DeviceNotifications.java
+++ /dev/null
@@ -1,235 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import java.util.ArrayList;
-import java.util.List;
-
-import android.app.KeyguardManager;
-import android.app.Notification;
-import android.app.PendingIntent;
-import android.content.Context;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.Builder;
-import androidx.core.app.NotificationCompat.InboxStyle;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-import com.fsck.k9.K9.NotificationHideSubject;
-import com.fsck.k9.K9.NotificationQuickDelete;
-import com.fsck.k9.NotificationSetting;
-import com.fsck.k9.controller.MessageReference;
-
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_BLINK_SLOW;
-
-
-class DeviceNotifications extends BaseNotifications {
- private final WearNotifications wearNotifications;
- private final LockScreenNotification lockScreenNotification;
-
-
- DeviceNotifications(NotificationHelper notificationHelper, NotificationActionCreator actionCreator,
- LockScreenNotification lockScreenNotification, WearNotifications wearNotifications,
- NotificationResourceProvider resourceProvider) {
- super(notificationHelper, actionCreator, resourceProvider);
- this.wearNotifications = wearNotifications;
- this.lockScreenNotification = lockScreenNotification;
- }
-
- public Notification buildSummaryNotification(Account account, NotificationData notificationData,
- boolean silent) {
- int unreadMessageCount = notificationData.getUnreadMessageCount();
-
- NotificationCompat.Builder builder;
- if (isPrivacyModeActive()) {
- builder = createSimpleSummaryNotification(account, unreadMessageCount);
- } else if (notificationData.isSingleMessageNotification()) {
- NotificationHolder holder = notificationData.getHolderForLatestNotification();
- builder = createBigTextStyleSummaryNotification(account, holder);
- } else {
- builder = createInboxStyleSummaryNotification(account, notificationData, unreadMessageCount);
- }
-
- if (notificationData.containsStarredMessages()) {
- builder.setPriority(NotificationCompat.PRIORITY_HIGH);
- }
-
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- PendingIntent deletePendingIntent = actionCreator.createDismissAllMessagesPendingIntent(
- account, notificationId);
- builder.setDeleteIntent(deletePendingIntent);
-
- lockScreenNotification.configureLockScreenNotification(builder, notificationData);
-
- boolean ringAndVibrate = false;
- if (!silent && !account.isRingNotified()) {
- account.setRingNotified(true);
- ringAndVibrate = true;
- }
-
- NotificationSetting notificationSetting = account.getNotificationSetting();
- notificationHelper.configureNotification(
- builder,
- (notificationSetting.isRingEnabled()) ? notificationSetting.getRingtone() : null,
- (notificationSetting.isVibrateEnabled()) ? notificationSetting.getVibration() : null,
- (notificationSetting.isLedEnabled()) ? notificationSetting.getLedColor() : null,
- NOTIFICATION_LED_BLINK_SLOW,
- ringAndVibrate);
-
- return builder.build();
- }
-
- private NotificationCompat.Builder createSimpleSummaryNotification(Account account, int unreadMessageCount) {
- String accountName = notificationHelper.getAccountName(account);
- CharSequence newMailText = resourceProvider.newMailTitle();
- String unreadMessageCountText = resourceProvider.newMailUnreadMessageCount(unreadMessageCount, accountName);
-
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- PendingIntent contentIntent = actionCreator.createViewFolderListPendingIntent(account, notificationId);
-
- return createAndInitializeNotificationBuilder(account)
- .setNumber(unreadMessageCount)
- .setTicker(newMailText)
- .setContentTitle(unreadMessageCountText)
- .setContentText(newMailText)
- .setContentIntent(contentIntent);
- }
-
- private NotificationCompat.Builder createBigTextStyleSummaryNotification(Account account,
- NotificationHolder holder) {
-
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- Builder builder = createBigTextStyleNotification(account, holder, notificationId)
- .setGroupSummary(true);
-
- NotificationContent content = holder.content;
- addReplyAction(builder, content, notificationId);
- addMarkAsReadAction(builder, content, notificationId);
- addDeleteAction(builder, content, notificationId);
-
- return builder;
- }
-
- private NotificationCompat.Builder createInboxStyleSummaryNotification(Account account,
- NotificationData notificationData, int unreadMessageCount) {
-
- NotificationHolder latestNotification = notificationData.getHolderForLatestNotification();
-
- int newMessagesCount = notificationData.getNewMessagesCount();
- String accountName = notificationHelper.getAccountName(account);
- String title = resourceProvider.newMessagesTitle(newMessagesCount);
- String summary = (notificationData.hasSummaryOverflowMessages()) ?
- resourceProvider.additionalMessages(notificationData.getSummaryOverflowMessagesCount(), accountName) :
- accountName;
- String groupKey = NotificationGroupKeys.getGroupKey(account);
-
- NotificationCompat.Builder builder = createAndInitializeNotificationBuilder(account)
- .setNumber(unreadMessageCount)
- .setTicker(latestNotification.content.summary)
- .setGroup(groupKey)
- .setGroupSummary(true)
- .setContentTitle(title)
- .setSubText(accountName);
-
- NotificationCompat.InboxStyle style = createInboxStyle(builder)
- .setBigContentTitle(title)
- .setSummaryText(summary);
-
- for (NotificationContent content : notificationData.getContentForSummaryNotification()) {
- style.addLine(content.summary);
- }
-
- builder.setStyle(style);
-
- addMarkAllAsReadAction(builder, notificationData);
- addDeleteAllAction(builder, notificationData);
-
- wearNotifications.addSummaryActions(builder, notificationData);
-
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- List messageReferences = notificationData.getAllMessageReferences();
- PendingIntent contentIntent = actionCreator.createViewMessagesPendingIntent(
- account, messageReferences, notificationId);
- builder.setContentIntent(contentIntent);
-
- return builder;
- }
-
- private void addMarkAsReadAction(Builder builder, NotificationContent content, int notificationId) {
- int icon = resourceProvider.getIconMarkAsRead();
- String title = resourceProvider.actionMarkAsRead();
-
-
- MessageReference messageReference = content.messageReference;
- PendingIntent action = actionCreator.createMarkMessageAsReadPendingIntent(messageReference, notificationId);
-
- builder.addAction(icon, title, action);
- }
-
- private void addMarkAllAsReadAction(Builder builder, NotificationData notificationData) {
- int icon = resourceProvider.getIconMarkAsRead();
- String title = resourceProvider.actionMarkAsRead();
-
- Account account = notificationData.getAccount();
- ArrayList messageReferences = notificationData.getAllMessageReferences();
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- PendingIntent markAllAsReadPendingIntent =
- actionCreator.createMarkAllAsReadPendingIntent(account, messageReferences, notificationId);
-
- builder.addAction(icon, title, markAllAsReadPendingIntent);
- }
-
- private void addDeleteAllAction(Builder builder, NotificationData notificationData) {
- if (K9.getNotificationQuickDeleteBehaviour() != NotificationQuickDelete.ALWAYS) {
- return;
- }
-
- int icon = resourceProvider.getIconDelete();
- String title = resourceProvider.actionDelete();
-
- Account account = notificationData.getAccount();
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- ArrayList messageReferences = notificationData.getAllMessageReferences();
- PendingIntent action = actionCreator.createDeleteAllPendingIntent(account, messageReferences, notificationId);
-
- builder.addAction(icon, title, action);
- }
-
- private void addDeleteAction(Builder builder, NotificationContent content, int notificationId) {
- if (!isDeleteActionEnabled()) {
- return;
- }
-
- int icon = resourceProvider.getIconDelete();
- String title = resourceProvider.actionDelete();
-
- MessageReference messageReference = content.messageReference;
- PendingIntent action = actionCreator.createDeleteMessagePendingIntent(messageReference, notificationId);
-
- builder.addAction(icon, title, action);
- }
-
- private void addReplyAction(Builder builder, NotificationContent content, int notificationId) {
- int icon = resourceProvider.getIconReply();
- String title = resourceProvider.actionReply();
-
- MessageReference messageReference = content.messageReference;
- PendingIntent replyToMessagePendingIntent =
- actionCreator.createReplyPendingIntent(messageReference, notificationId);
-
- builder.addAction(icon, title, replyToMessagePendingIntent);
- }
-
- private boolean isPrivacyModeActive() {
- KeyguardManager keyguardService = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
-
- boolean privacyModeAlwaysEnabled = K9.getNotificationHideSubject() == NotificationHideSubject.ALWAYS;
- boolean privacyModeEnabledWhenLocked = K9.getNotificationHideSubject() == NotificationHideSubject.WHEN_LOCKED;
- boolean screenLocked = keyguardService.inKeyguardRestrictedInputMode();
-
- return privacyModeAlwaysEnabled || (privacyModeEnabledWhenLocked && screenLocked);
- }
-
- protected InboxStyle createInboxStyle(Builder builder) {
- return new InboxStyle(builder);
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotification.java b/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotification.java
deleted file mode 100644
index 3884f3276273f98269282ac6521363c1a00c7361..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotification.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-import android.app.Notification;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.Builder;
-import android.text.TextUtils;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-
-
-class LockScreenNotification {
- static final int MAX_NUMBER_OF_SENDERS_IN_LOCK_SCREEN_NOTIFICATION = 5;
-
-
- private final NotificationHelper notificationHelper;
- private final NotificationResourceProvider resourceProvider;
-
-
- LockScreenNotification(NotificationHelper notificationHelper, NotificationResourceProvider resourceProvider) {
- this.notificationHelper = notificationHelper;
- this.resourceProvider = resourceProvider;
- }
-
- public void configureLockScreenNotification(Builder builder, NotificationData notificationData) {
- switch (K9.getLockScreenNotificationVisibility()) {
- case NOTHING: {
- builder.setVisibility(NotificationCompat.VISIBILITY_SECRET);
- break;
- }
- case APP_NAME: {
- builder.setVisibility(NotificationCompat.VISIBILITY_PRIVATE);
- break;
- }
- case EVERYTHING: {
- builder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
- break;
- }
- case SENDERS: {
- Notification publicNotification = createPublicNotificationWithSenderList(notificationData);
- builder.setPublicVersion(publicNotification);
- break;
- }
- case MESSAGE_COUNT: {
- Notification publicNotification = createPublicNotificationWithNewMessagesCount(notificationData);
- builder.setPublicVersion(publicNotification);
- break;
- }
- }
- }
-
- private Notification createPublicNotificationWithSenderList(NotificationData notificationData) {
- Builder builder = createPublicNotification(notificationData);
- int newMessages = notificationData.getNewMessagesCount();
- if (newMessages == 1) {
- NotificationHolder holder = notificationData.getHolderForLatestNotification();
- builder.setContentText(holder.content.sender);
- } else {
- List contents = notificationData.getContentForSummaryNotification();
- String senderList = createCommaSeparatedListOfSenders(contents);
- builder.setContentText(senderList);
- }
-
- return builder.build();
- }
-
- private Notification createPublicNotificationWithNewMessagesCount(NotificationData notificationData) {
- Builder builder = createPublicNotification(notificationData);
- Account account = notificationData.getAccount();
- String accountName = notificationHelper.getAccountName(account);
- builder.setContentText(accountName);
-
- return builder.build();
- }
-
- private Builder createPublicNotification(NotificationData notificationData) {
- Account account = notificationData.getAccount();
- int newMessages = notificationData.getNewMessagesCount();
- int unreadCount = notificationData.getUnreadMessageCount();
- String title = resourceProvider.newMessagesTitle(newMessages);
-
- return notificationHelper.createNotificationBuilder(account,
- NotificationChannelManager.ChannelType.MESSAGES)
- .setSmallIcon(resourceProvider.getIconNewMail())
- .setColor(account.getChipColor())
- .setNumber(unreadCount)
- .setContentTitle(title)
- .setCategory(NotificationCompat.CATEGORY_EMAIL);
- }
-
-
- String createCommaSeparatedListOfSenders(List contents) {
- // Use a LinkedHashSet so that we preserve ordering (newest to oldest), but still remove duplicates
- Set senders = new LinkedHashSet<>(MAX_NUMBER_OF_SENDERS_IN_LOCK_SCREEN_NOTIFICATION);
- for (NotificationContent content : contents) {
- senders.add(content.sender);
- if (senders.size() == MAX_NUMBER_OF_SENDERS_IN_LOCK_SCREEN_NOTIFICATION) {
- break;
- }
- }
-
- return TextUtils.join(", ", senders);
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotificationCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotificationCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e071201c0dac8659ebff93614f9a332094354f85
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/LockScreenNotificationCreator.kt
@@ -0,0 +1,60 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+import androidx.core.app.NotificationCompat
+
+internal class LockScreenNotificationCreator(
+ private val notificationHelper: NotificationHelper,
+ private val resourceProvider: NotificationResourceProvider
+) {
+ fun configureLockScreenNotification(
+ builder: NotificationCompat.Builder,
+ baseNotificationData: BaseNotificationData
+ ) {
+ when (baseNotificationData.lockScreenNotificationData) {
+ LockScreenNotificationData.None -> {
+ builder.setVisibility(NotificationCompat.VISIBILITY_SECRET)
+ }
+ LockScreenNotificationData.AppName -> {
+ builder.setVisibility(NotificationCompat.VISIBILITY_PRIVATE)
+ }
+ LockScreenNotificationData.Public -> {
+ builder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+ }
+ is LockScreenNotificationData.SenderNames -> {
+ val publicNotification = createPublicNotificationWithSenderList(baseNotificationData)
+ builder.setPublicVersion(publicNotification)
+ }
+ LockScreenNotificationData.MessageCount -> {
+ val publicNotification = createPublicNotificationWithNewMessagesCount(baseNotificationData)
+ builder.setPublicVersion(publicNotification)
+ }
+ }
+ }
+
+ private fun createPublicNotificationWithSenderList(baseNotificationData: BaseNotificationData): Notification {
+ val notificationData = baseNotificationData.lockScreenNotificationData as LockScreenNotificationData.SenderNames
+ return createPublicNotification(baseNotificationData)
+ .setContentText(notificationData.senderNames)
+ .build()
+ }
+
+ private fun createPublicNotificationWithNewMessagesCount(baseNotificationData: BaseNotificationData): Notification {
+ return createPublicNotification(baseNotificationData)
+ .setContentText(baseNotificationData.accountName)
+ .build()
+ }
+
+ private fun createPublicNotification(baseNotificationData: BaseNotificationData): NotificationCompat.Builder {
+ val account = baseNotificationData.account
+ val newMessagesCount = baseNotificationData.newMessagesCount
+ val title = resourceProvider.newMessagesTitle(newMessagesCount)
+
+ return notificationHelper.createNotificationBuilder(account, NotificationChannelManager.ChannelType.MESSAGES)
+ .setSmallIcon(resourceProvider.iconNewMail)
+ .setColor(baseNotificationData.color)
+ .setNumber(newMessagesCount)
+ .setContentTitle(title)
+ .setCategory(NotificationCompat.CATEGORY_EMAIL)
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..190144862113200f25529bceef710962cc23c44e
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationController.kt
@@ -0,0 +1,86 @@
+package com.fsck.k9.notification
+
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.mailstore.LocalMessage
+
+/**
+ * Handle notifications for new messages.
+ */
+internal class NewMailNotificationController(
+ private val notificationManager: NotificationManagerCompat,
+ private val newMailNotificationManager: NewMailNotificationManager,
+ private val summaryNotificationCreator: SummaryNotificationCreator,
+ private val singleMessageNotificationCreator: SingleMessageNotificationCreator
+) {
+ fun restoreNewMailNotifications(accounts: List) {
+ for (account in accounts) {
+ val notificationData = newMailNotificationManager.restoreNewMailNotifications(account)
+
+ if (notificationData != null) {
+ processNewMailNotificationData(notificationData)
+ }
+ }
+ }
+
+ fun addNewMailNotification(account: Account, message: LocalMessage, silent: Boolean) {
+ val notificationData = newMailNotificationManager.addNewMailNotification(account, message, silent)
+
+ processNewMailNotificationData(notificationData)
+ }
+
+ fun removeNewMailNotifications(
+ account: Account,
+ clearNewMessageState: Boolean,
+ selector: (List) -> List
+ ) {
+ val notificationData = newMailNotificationManager.removeNewMailNotifications(
+ account,
+ clearNewMessageState,
+ selector
+ )
+
+ if (notificationData != null) {
+ processNewMailNotificationData(notificationData)
+ }
+ }
+
+ fun clearNewMailNotifications(account: Account, clearNewMessageState: Boolean) {
+ val cancelNotificationIds = newMailNotificationManager.clearNewMailNotifications(account, clearNewMessageState)
+
+ cancelNotifications(cancelNotificationIds)
+ }
+
+ private fun processNewMailNotificationData(notificationData: NewMailNotificationData) {
+ cancelNotifications(notificationData.cancelNotificationIds)
+
+ for (singleNotificationData in notificationData.singleNotificationData) {
+ createSingleNotification(notificationData.baseNotificationData, singleNotificationData)
+ }
+
+ notificationData.summaryNotificationData?.let { summaryNotificationData ->
+ createSummaryNotification(notificationData.baseNotificationData, summaryNotificationData)
+ }
+ }
+
+ private fun cancelNotifications(notificationIds: List) {
+ for (notificationId in notificationIds) {
+ notificationManager.cancel(notificationId)
+ }
+ }
+
+ private fun createSingleNotification(
+ baseNotificationData: BaseNotificationData,
+ singleNotificationData: SingleNotificationData
+ ) {
+ singleMessageNotificationCreator.createSingleNotification(baseNotificationData, singleNotificationData)
+ }
+
+ private fun createSummaryNotification(
+ baseNotificationData: BaseNotificationData,
+ summaryNotificationData: SummaryNotificationData
+ ) {
+ summaryNotificationCreator.createSummaryNotification(baseNotificationData, summaryNotificationData)
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationData.kt b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationData.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9069b4f85ada8b1d1e66f855afff48b7df5df598
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationData.kt
@@ -0,0 +1,87 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+
+internal data class NewMailNotificationData(
+ val cancelNotificationIds: List,
+ val baseNotificationData: BaseNotificationData,
+ val singleNotificationData: List,
+ val summaryNotificationData: SummaryNotificationData?
+)
+
+internal data class BaseNotificationData(
+ val account: Account,
+ val accountName: String,
+ val groupKey: String,
+ val color: Int,
+ val newMessagesCount: Int,
+ val lockScreenNotificationData: LockScreenNotificationData,
+ val appearance: NotificationAppearance
+)
+
+internal sealed interface LockScreenNotificationData {
+ object None : LockScreenNotificationData
+ object AppName : LockScreenNotificationData
+ object Public : LockScreenNotificationData
+ object MessageCount : LockScreenNotificationData
+ data class SenderNames(val senderNames: String) : LockScreenNotificationData
+}
+
+internal data class NotificationAppearance(
+ val ringtone: String?,
+ val vibrationPattern: LongArray?,
+ val ledColor: Int?
+)
+
+internal data class SingleNotificationData(
+ val notificationId: Int,
+ val isSilent: Boolean,
+ val timestamp: Long,
+ val content: NotificationContent,
+ val actions: List,
+ val wearActions: List,
+ val addLockScreenNotification: Boolean
+)
+
+internal sealed interface SummaryNotificationData
+
+internal data class SummarySingleNotificationData(
+ val singleNotificationData: SingleNotificationData
+) : SummaryNotificationData
+
+internal data class SummaryInboxNotificationData(
+ val notificationId: Int,
+ val isSilent: Boolean,
+ val timestamp: Long,
+ val content: List,
+ val additionalMessagesCount: Int,
+ val messageReferences: List,
+ val actions: List,
+ val wearActions: List
+) : SummaryNotificationData
+
+internal enum class NotificationAction {
+ Reply,
+ MarkAsRead,
+ Delete
+}
+
+internal enum class WearNotificationAction {
+ Reply,
+ MarkAsRead,
+ Delete,
+ Archive,
+ Spam
+}
+
+internal enum class SummaryNotificationAction {
+ MarkAsRead,
+ Delete
+}
+
+internal enum class SummaryWearNotificationAction {
+ MarkAsRead,
+ Delete,
+ Archive
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationManager.kt b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationManager.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8e1a8c3fe2645aacaaf5b48b7d083b458f862ffa
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotificationManager.kt
@@ -0,0 +1,134 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.Clock
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.mailstore.LocalMessage
+
+/**
+ * Manages notifications for new messages
+ */
+internal class NewMailNotificationManager(
+ private val contentCreator: NotificationContentCreator,
+ private val notificationRepository: NotificationRepository,
+ private val baseNotificationDataCreator: BaseNotificationDataCreator,
+ private val singleMessageNotificationDataCreator: SingleMessageNotificationDataCreator,
+ private val summaryNotificationDataCreator: SummaryNotificationDataCreator,
+ private val clock: Clock
+) {
+ fun restoreNewMailNotifications(account: Account): NewMailNotificationData? {
+ val notificationData = notificationRepository.restoreNotifications(account) ?: return null
+
+ val addLockScreenNotification = notificationData.isSingleMessageNotification
+ val singleNotificationDataList = notificationData.activeNotifications.map { notificationHolder ->
+ createSingleNotificationData(
+ account = account,
+ notificationId = notificationHolder.notificationId,
+ content = notificationHolder.content,
+ timestamp = notificationHolder.timestamp,
+ addLockScreenNotification = addLockScreenNotification
+ )
+ }
+
+ return NewMailNotificationData(
+ cancelNotificationIds = emptyList(),
+ baseNotificationData = createBaseNotificationData(notificationData),
+ singleNotificationData = singleNotificationDataList,
+ summaryNotificationData = createSummaryNotificationData(notificationData, silent = true)
+ )
+ }
+
+ fun addNewMailNotification(account: Account, message: LocalMessage, silent: Boolean): NewMailNotificationData {
+ val content = contentCreator.createFromMessage(account, message)
+
+ val result = notificationRepository.addNotification(account, content, timestamp = now())
+
+ val singleNotificationData = createSingleNotificationData(
+ account = account,
+ notificationId = result.notificationHolder.notificationId,
+ content = result.notificationHolder.content,
+ timestamp = result.notificationHolder.timestamp,
+ addLockScreenNotification = result.notificationData.isSingleMessageNotification
+ )
+
+ return NewMailNotificationData(
+ cancelNotificationIds = if (result.shouldCancelNotification) {
+ listOf(result.cancelNotificationId)
+ } else {
+ emptyList()
+ },
+ baseNotificationData = createBaseNotificationData(result.notificationData),
+ singleNotificationData = listOf(singleNotificationData),
+ summaryNotificationData = createSummaryNotificationData(result.notificationData, silent)
+ )
+ }
+
+ fun removeNewMailNotifications(
+ account: Account,
+ clearNewMessageState: Boolean,
+ selector: (List) -> List
+ ): NewMailNotificationData? {
+ val result = notificationRepository.removeNotifications(account, clearNewMessageState, selector) ?: return null
+
+ val cancelNotificationIds = when {
+ result.notificationData.isEmpty() -> {
+ result.cancelNotificationIds + NotificationIds.getNewMailSummaryNotificationId(account)
+ }
+ else -> {
+ result.cancelNotificationIds
+ }
+ }
+
+ val singleNotificationData = result.notificationHolders.map { notificationHolder ->
+ createSingleNotificationData(
+ account = account,
+ notificationId = notificationHolder.notificationId,
+ content = notificationHolder.content,
+ timestamp = notificationHolder.timestamp,
+ addLockScreenNotification = result.notificationData.isSingleMessageNotification
+ )
+ }
+
+ return NewMailNotificationData(
+ cancelNotificationIds = cancelNotificationIds,
+ baseNotificationData = createBaseNotificationData(result.notificationData),
+ singleNotificationData = singleNotificationData,
+ summaryNotificationData = createSummaryNotificationData(result.notificationData, silent = true)
+ )
+ }
+
+ fun clearNewMailNotifications(account: Account, clearNewMessageState: Boolean): List {
+ notificationRepository.clearNotifications(account, clearNewMessageState)
+ return NotificationIds.getAllMessageNotificationIds(account)
+ }
+
+ private fun createBaseNotificationData(notificationData: NotificationData): BaseNotificationData {
+ return baseNotificationDataCreator.createBaseNotificationData(notificationData)
+ }
+
+ private fun createSingleNotificationData(
+ account: Account,
+ notificationId: Int,
+ content: NotificationContent,
+ timestamp: Long,
+ addLockScreenNotification: Boolean
+ ): SingleNotificationData {
+ return singleMessageNotificationDataCreator.createSingleNotificationData(
+ account,
+ notificationId,
+ content,
+ timestamp,
+ addLockScreenNotification
+ )
+ }
+
+ private fun createSummaryNotificationData(data: NotificationData, silent: Boolean): SummaryNotificationData? {
+ return if (data.isEmpty()) {
+ null
+ } else {
+ summaryNotificationDataCreator.createSummaryNotificationData(data, silent)
+ }
+ }
+
+ private fun now(): Long = clock.time
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NewMailNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/NewMailNotifications.java
deleted file mode 100644
index 8fc8ae5e270abcbce8e4f9911891b6c68a4e50d8..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NewMailNotifications.java
+++ /dev/null
@@ -1,167 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.app.Notification;
-import androidx.core.app.NotificationManagerCompat;
-import android.util.SparseArray;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-import com.fsck.k9.K9.NotificationHideSubject;
-import com.fsck.k9.controller.MessageReference;
-import com.fsck.k9.mailstore.LocalMessage;
-
-
-/**
- * Handle notifications for new messages.
- *
- * We call the notification shown on the device summary notification, even when there's only one new message.
- * Notifications on an Android Wear device are displayed as a stack of cards and that's why we call them stacked
- * notifications. We have to keep track of stacked notifications individually and recreate/update the summary
- * notification when one or more of the stacked notifications are added/removed.
- * {@link NotificationData} keeps track of all data required to (re)create the actual system notifications.
- *
- */
-class NewMailNotifications {
- private final NotificationHelper notificationHelper;
- private final NotificationContentCreator contentCreator;
- private final DeviceNotifications deviceNotifications;
- private final WearNotifications wearNotifications;
- private final SparseArray notifications = new SparseArray<>();
- private final Object lock = new Object();
-
-
- NewMailNotifications(NotificationHelper notificationHelper, NotificationContentCreator contentCreator,
- DeviceNotifications deviceNotifications, WearNotifications wearNotifications) {
- this.notificationHelper = notificationHelper;
- this.deviceNotifications = deviceNotifications;
- this.wearNotifications = wearNotifications;
- this.contentCreator = contentCreator;
- }
-
- public void addNewMailNotification(Account account, LocalMessage message, int unreadMessageCount) {
- NotificationContent content = contentCreator.createFromMessage(account, message);
-
- synchronized (lock) {
- NotificationData notificationData = getOrCreateNotificationData(account, unreadMessageCount);
- AddNotificationResult result = notificationData.addNotificationContent(content);
-
- if (result.shouldCancelNotification()) {
- int notificationId = result.getNotificationId();
- cancelNotification(notificationId);
- }
-
- createStackedNotification(account, result.getNotificationHolder());
- createSummaryNotification(account, notificationData, false);
- }
- }
-
- public void removeNewMailNotification(Account account, MessageReference messageReference) {
- synchronized (lock) {
- NotificationData notificationData = getNotificationData(account);
- if (notificationData == null) {
- return;
- }
-
- RemoveNotificationResult result = notificationData.removeNotificationForMessage(messageReference);
- if (result.isUnknownNotification()) {
- return;
- }
-
- cancelNotification(result.getNotificationId());
-
- if (result.shouldCreateNotification()) {
- createStackedNotification(account, result.getNotificationHolder());
- }
-
- updateSummaryNotification(account, notificationData);
- }
- }
-
- public void clearNewMailNotifications(Account account) {
- NotificationData notificationData;
- synchronized (lock) {
- notificationData = removeNotificationData(account);
- }
-
- if (notificationData == null) {
- return;
- }
-
- for (int notificationId : notificationData.getActiveNotificationIds()) {
- cancelNotification(notificationId);
- }
-
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
- cancelNotification(notificationId);
- }
-
- private NotificationData getOrCreateNotificationData(Account account, int unreadMessageCount) {
- NotificationData notificationData = getNotificationData(account);
- if (notificationData != null) {
- return notificationData;
- }
-
- int accountNumber = account.getAccountNumber();
- NotificationData newNotificationHolder = createNotificationData(account, unreadMessageCount);
- notifications.put(accountNumber, newNotificationHolder);
-
- return newNotificationHolder;
- }
-
- private NotificationData getNotificationData(Account account) {
- int accountNumber = account.getAccountNumber();
- return notifications.get(accountNumber);
- }
-
- private NotificationData removeNotificationData(Account account) {
- int accountNumber = account.getAccountNumber();
- NotificationData notificationData = notifications.get(accountNumber);
- notifications.remove(accountNumber);
- return notificationData;
- }
-
- NotificationData createNotificationData(Account account, int unreadMessageCount) {
- NotificationData notificationData = new NotificationData(account);
- notificationData.setUnreadMessageCount(unreadMessageCount);
- return notificationData;
- }
-
- private void cancelNotification(int notificationId) {
- getNotificationManager().cancel(notificationId);
- }
-
- private void updateSummaryNotification(Account account, NotificationData notificationData) {
- if (notificationData.getNewMessagesCount() == 0) {
- clearNewMailNotifications(account);
- } else {
- createSummaryNotification(account, notificationData, true);
- }
- }
-
- private void createSummaryNotification(Account account, NotificationData notificationData, boolean silent) {
- Notification notification = deviceNotifications.buildSummaryNotification(account, notificationData, silent);
- int notificationId = NotificationIds.getNewMailSummaryNotificationId(account);
-
- getNotificationManager().notify(notificationId, notification);
- }
-
- private void createStackedNotification(Account account, NotificationHolder holder) {
- if (isPrivacyModeEnabled()) {
- return;
- }
-
- Notification notification = wearNotifications.buildStackedNotification(account, holder);
- int notificationId = holder.notificationId;
-
- getNotificationManager().notify(notificationId, notification);
- }
-
- private boolean isPrivacyModeEnabled() {
- return K9.getNotificationHideSubject() != NotificationHideSubject.NEVER;
- }
-
- private NotificationManagerCompat getNotificationManager() {
- return notificationHelper.getNotificationManager();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.java
deleted file mode 100644
index 94e781c4d8f835841d339d576ea274e3a8625c63..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import java.util.List;
-
-import android.app.PendingIntent;
-import android.content.Context;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.controller.MessageReference;
-
-
-public interface NotificationActionCreator {
- PendingIntent createViewMessagePendingIntent(MessageReference messageReference, int notificationId);
-
- PendingIntent createViewFolderPendingIntent(Account account, long folderId, int notificationId);
-
- PendingIntent createViewMessagesPendingIntent(Account account, List messageReferences,
- int notificationId);
-
- PendingIntent createViewFolderListPendingIntent(Account account, int notificationId);
-
- PendingIntent createDismissAllMessagesPendingIntent(Account account, int notificationId);
-
- PendingIntent createDismissMessagePendingIntent(Context context, MessageReference messageReference,
- int notificationId);
-
- PendingIntent createReplyPendingIntent(MessageReference messageReference, int notificationId);
-
- PendingIntent createMarkMessageAsReadPendingIntent(MessageReference messageReference, int notificationId);
-
- PendingIntent createMarkAllAsReadPendingIntent(Account account, List messageReferences,
- int notificationId);
-
- PendingIntent getEditIncomingServerSettingsIntent(Account account);
-
- PendingIntent getEditOutgoingServerSettingsIntent(Account account);
-
- PendingIntent createDeleteMessagePendingIntent(MessageReference messageReference, int notificationId);
-
- PendingIntent createDeleteAllPendingIntent(Account account, List messageReferences,
- int notificationId);
-
- PendingIntent createArchiveMessagePendingIntent(MessageReference messageReference, int notificationId);
-
- PendingIntent createArchiveAllPendingIntent(Account account, List messageReferences,
- int notificationId);
-
- PendingIntent createMarkMessageAsSpamPendingIntent(MessageReference messageReference, int notificationId);
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7e403b8c315bbd1d65326ab97bddfd161bbc6d0
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionCreator.kt
@@ -0,0 +1,58 @@
+package com.fsck.k9.notification
+
+import android.app.PendingIntent
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+
+interface NotificationActionCreator {
+ fun createViewMessagePendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+
+ fun createViewFolderPendingIntent(account: Account, folderId: Long, notificationId: Int): PendingIntent
+
+ fun createViewMessagesPendingIntent(
+ account: Account,
+ messageReferences: List,
+ notificationId: Int
+ ): PendingIntent
+
+ fun createViewFolderListPendingIntent(account: Account, notificationId: Int): PendingIntent
+
+ fun createDismissAllMessagesPendingIntent(account: Account, notificationId: Int): PendingIntent
+
+ fun createDismissMessagePendingIntent(
+ messageReference: MessageReference,
+ notificationId: Int
+ ): PendingIntent
+
+ fun createReplyPendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+
+ fun createMarkMessageAsReadPendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+
+ fun createMarkAllAsReadPendingIntent(
+ account: Account,
+ messageReferences: List,
+ notificationId: Int
+ ): PendingIntent
+
+ fun getEditIncomingServerSettingsIntent(account: Account): PendingIntent
+
+ fun getEditOutgoingServerSettingsIntent(account: Account): PendingIntent
+
+ fun createDeleteMessagePendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+
+ fun createDeleteAllPendingIntent(
+ account: Account,
+ messageReferences: List,
+ notificationId: Int
+ ): PendingIntent
+
+ fun createArchiveMessagePendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+
+ fun createArchiveAllPendingIntent(
+ account: Account,
+ messageReferences: List,
+ notificationId: Int
+ ): PendingIntent
+
+ fun createMarkMessageAsSpamPendingIntent(messageReference: MessageReference, notificationId: Int): PendingIntent
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.java
deleted file mode 100644
index a0453579e60ed0420fed713c77eed9ece3546e9e..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.java
+++ /dev/null
@@ -1,247 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import java.util.ArrayList;
-import java.util.List;
-
-import android.app.Service;
-import android.content.Context;
-import android.content.Intent;
-import android.os.IBinder;
-
-import androidx.annotation.Nullable;
-
-import timber.log.Timber;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-import com.fsck.k9.Preferences;
-import com.fsck.k9.controller.MessageReference;
-import com.fsck.k9.controller.MessagingController;
-import com.fsck.k9.mail.Flag;
-
-import static com.fsck.k9.controller.MessageReferenceHelper.toMessageReferenceList;
-import static com.fsck.k9.controller.MessageReferenceHelper.toMessageReferenceStringList;
-
-
-public class NotificationActionService extends Service {
- private static final String ACTION_MARK_AS_READ = "ACTION_MARK_AS_READ";
- private static final String ACTION_DELETE = "ACTION_DELETE";
- private static final String ACTION_ARCHIVE = "ACTION_ARCHIVE";
- private static final String ACTION_SPAM = "ACTION_SPAM";
- private static final String ACTION_DISMISS = "ACTION_DISMISS";
-
- private static final String EXTRA_ACCOUNT_UUID = "accountUuid";
- private static final String EXTRA_MESSAGE_REFERENCE = "messageReference";
- private static final String EXTRA_MESSAGE_REFERENCES = "messageReferences";
-
-
- public static Intent createMarkMessageAsReadIntent(Context context, MessageReference messageReference) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_MARK_AS_READ);
- intent.putExtra(EXTRA_ACCOUNT_UUID, messageReference.getAccountUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference));
-
- return intent;
- }
-
- public static Intent createMarkAllAsReadIntent(Context context, String accountUuid,
- List messageReferences) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_MARK_AS_READ);
- intent.putExtra(EXTRA_ACCOUNT_UUID, accountUuid);
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, toMessageReferenceStringList(messageReferences));
-
- return intent;
- }
-
- public static Intent createDismissMessageIntent(Context context, MessageReference messageReference) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_DISMISS);
- intent.putExtra(EXTRA_ACCOUNT_UUID, messageReference.getAccountUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCE, messageReference.toIdentityString());
-
- return intent;
- }
-
- public static Intent createDismissAllMessagesIntent(Context context, Account account) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_DISMISS);
- intent.putExtra(EXTRA_ACCOUNT_UUID, account.getUuid());
-
- return intent;
- }
-
- public static Intent createDeleteMessageIntent(Context context, MessageReference messageReference) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_DELETE);
- intent.putExtra(EXTRA_ACCOUNT_UUID, messageReference.getAccountUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference));
-
- return intent;
- }
-
- public static Intent createDeleteAllMessagesIntent(Context context, String accountUuid,
- List messageReferences) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_DELETE);
- intent.putExtra(EXTRA_ACCOUNT_UUID, accountUuid);
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, toMessageReferenceStringList(messageReferences));
-
- return intent;
- }
-
- public static Intent createArchiveMessageIntent(Context context, MessageReference messageReference) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_ARCHIVE);
- intent.putExtra(EXTRA_ACCOUNT_UUID, messageReference.getAccountUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference));
-
- return intent;
- }
-
- public static Intent createArchiveAllIntent(Context context, Account account,
- List messageReferences) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_ARCHIVE);
- intent.putExtra(EXTRA_ACCOUNT_UUID, account.getUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCES, toMessageReferenceStringList(messageReferences));
-
- return intent;
- }
-
- public static Intent createMarkMessageAsSpamIntent(Context context, MessageReference messageReference) {
- Intent intent = new Intent(context, NotificationActionService.class);
- intent.setAction(ACTION_SPAM);
- intent.putExtra(EXTRA_ACCOUNT_UUID, messageReference.getAccountUuid());
- intent.putExtra(EXTRA_MESSAGE_REFERENCE, messageReference.toIdentityString());
-
- return intent;
- }
-
- private static ArrayList createSingleItemArrayList(MessageReference messageReference) {
- ArrayList messageReferenceStrings = new ArrayList<>(1);
- messageReferenceStrings.add(messageReference.toIdentityString());
- return messageReferenceStrings;
- }
-
- @Override
- public final int onStartCommand(Intent intent, int flags, int startId) {
- Timber.i("NotificationActionService started with startId = %d", startId);
-
- String accountUuid = intent.getStringExtra(EXTRA_ACCOUNT_UUID);
- Preferences preferences = Preferences.getPreferences(this);
- Account account = preferences.getAccount(accountUuid);
-
- if (account == null) {
- Timber.w("Could not find account for notification action.");
- return START_NOT_STICKY;
- }
-
- MessagingController controller = MessagingController.getInstance(getApplication());
-
- String action = intent.getAction();
- if (ACTION_MARK_AS_READ.equals(action)) {
- markMessagesAsRead(intent, account, controller);
- } else if (ACTION_DELETE.equals(action)) {
- deleteMessages(intent, controller);
- } else if (ACTION_ARCHIVE.equals(action)) {
- archiveMessages(intent, account, controller);
- } else if (ACTION_SPAM.equals(action)) {
- markMessageAsSpam(intent, account, controller);
- } else if (ACTION_DISMISS.equals(action)) {
- Timber.i("Notification dismissed");
- }
-
- cancelNotifications(intent, account, controller);
-
- return START_NOT_STICKY;
- }
-
- @Nullable
- @Override
- public IBinder onBind(Intent intent) {
- return null;
- }
-
- private void markMessagesAsRead(Intent intent, Account account, MessagingController controller) {
- Timber.i("NotificationActionService marking messages as read");
-
- List messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES);
- List messageReferences = toMessageReferenceList(messageReferenceStrings);
- for (MessageReference messageReference : messageReferences) {
- long folderId = messageReference.getFolderId();
- String uid = messageReference.getUid();
- controller.setFlag(account, folderId, uid, Flag.SEEN, true);
- }
- }
-
- private void deleteMessages(Intent intent, MessagingController controller) {
- Timber.i("NotificationActionService deleting messages");
-
- List messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES);
- List messageReferences = toMessageReferenceList(messageReferenceStrings);
- controller.deleteMessages(messageReferences);
- }
-
- private void archiveMessages(Intent intent, Account account, MessagingController controller) {
- Timber.i("NotificationActionService archiving messages");
-
- Long archiveFolderId = account.getArchiveFolderId();
- if (!isMovePossible(controller, account, archiveFolderId)) {
- Timber.w("Can not archive messages");
- return;
- }
-
- List messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES);
- List messageReferences = toMessageReferenceList(messageReferenceStrings);
- for (MessageReference messageReference : messageReferences) {
- if (controller.isMoveCapable(messageReference)) {
- long sourceFolderId = messageReference.getFolderId();
- controller.moveMessage(account, sourceFolderId, messageReference, archiveFolderId);
- }
- }
- }
-
- private void markMessageAsSpam(Intent intent, Account account, MessagingController controller) {
- Timber.i("NotificationActionService moving messages to spam");
-
- String messageReferenceString = intent.getStringExtra(EXTRA_MESSAGE_REFERENCE);
- MessageReference messageReference = MessageReference.parse(messageReferenceString);
- if (messageReference == null) {
- Timber.w("Invalid message reference: %s", messageReferenceString);
- return;
- }
-
- Long spamFolderId = account.getSpamFolderId();
- if (!K9.isConfirmSpam() && isMovePossible(controller, account, spamFolderId)) {
- long sourceFolderId = messageReference.getFolderId();
- controller.moveMessage(account, sourceFolderId, messageReference, spamFolderId);
- }
- }
-
- private void cancelNotifications(Intent intent, Account account, MessagingController controller) {
- if (intent.hasExtra(EXTRA_MESSAGE_REFERENCE)) {
- String messageReferenceString = intent.getStringExtra(EXTRA_MESSAGE_REFERENCE);
- MessageReference messageReference = MessageReference.parse(messageReferenceString);
- if (messageReference != null) {
- controller.cancelNotificationForMessage(account, messageReference);
- } else {
- Timber.w("Invalid message reference: %s", messageReferenceString);
- }
- } else if (intent.hasExtra(EXTRA_MESSAGE_REFERENCES)) {
- List messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES);
- List messageReferences = toMessageReferenceList(messageReferenceStrings);
- for (MessageReference messageReference : messageReferences) {
- controller.cancelNotificationForMessage(account, messageReference);
- }
- } else {
- controller.cancelNotificationsForAccount(account);
- }
- }
-
- private boolean isMovePossible(MessagingController controller, Account account, Long destinationFolderId) {
- boolean isSpecialFolderConfigured = destinationFolderId != null;
- return isSpecialFolderConfigured && controller.isMoveCapable(account);
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d70ea87778326e3c891c99868bf21dc387dd459c
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationActionService.kt
@@ -0,0 +1,244 @@
+package com.fsck.k9.notification
+
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.IBinder
+import com.fsck.k9.Account
+import com.fsck.k9.K9
+import com.fsck.k9.Preferences
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.controller.MessageReferenceHelper
+import com.fsck.k9.controller.MessagingController
+import com.fsck.k9.mail.Flag
+import org.koin.android.ext.android.inject
+import timber.log.Timber
+
+class NotificationActionService : Service() {
+ private val preferences: Preferences by inject()
+ private val messagingController: MessagingController by inject()
+
+ override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
+ Timber.i("NotificationActionService started with startId = %d", startId)
+
+ val accountUuid = intent.getStringExtra(EXTRA_ACCOUNT_UUID) ?: error("Missing account UUID")
+
+ val account = preferences.getAccount(accountUuid)
+ if (account == null) {
+ Timber.w("Could not find account for notification action.")
+ return START_NOT_STICKY
+ }
+
+ when (intent.action) {
+ ACTION_MARK_AS_READ -> markMessagesAsRead(intent, account)
+ ACTION_DELETE -> deleteMessages(intent)
+ ACTION_ARCHIVE -> archiveMessages(intent, account)
+ ACTION_SPAM -> markMessageAsSpam(intent, account)
+ ACTION_DISMISS -> Timber.i("Notification dismissed")
+ }
+
+ cancelNotifications(intent, account)
+
+ return START_NOT_STICKY
+ }
+
+ override fun onBind(intent: Intent): IBinder? {
+ return null
+ }
+
+ private fun markMessagesAsRead(intent: Intent, account: Account) {
+ Timber.i("NotificationActionService marking messages as read")
+
+ val messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES)
+ val messageReferences = MessageReferenceHelper.toMessageReferenceList(messageReferenceStrings)
+
+ for (messageReference in messageReferences) {
+ val folderId = messageReference.folderId
+ val uid = messageReference.uid
+ messagingController.setFlag(account, folderId, uid, Flag.SEEN, true)
+ }
+ }
+
+ private fun deleteMessages(intent: Intent) {
+ Timber.i("NotificationActionService deleting messages")
+
+ val messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES)
+ val messageReferences = MessageReferenceHelper.toMessageReferenceList(messageReferenceStrings)
+
+ messagingController.deleteMessages(messageReferences)
+ }
+
+ private fun archiveMessages(intent: Intent, account: Account) {
+ Timber.i("NotificationActionService archiving messages")
+
+ val archiveFolderId = account.archiveFolderId
+ if (archiveFolderId == null || !messagingController.isMoveCapable(account)) {
+ Timber.w("Cannot archive messages")
+ return
+ }
+
+ val messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES)
+ val messageReferences = MessageReferenceHelper.toMessageReferenceList(messageReferenceStrings)
+
+ for (messageReference in messageReferences) {
+ if (messagingController.isMoveCapable(messageReference)) {
+ val sourceFolderId = messageReference.folderId
+ messagingController.moveMessage(account, sourceFolderId, messageReference, archiveFolderId)
+ }
+ }
+ }
+
+ private fun markMessageAsSpam(intent: Intent, account: Account) {
+ Timber.i("NotificationActionService moving messages to spam")
+
+ val messageReferenceString = intent.getStringExtra(EXTRA_MESSAGE_REFERENCE)
+ val messageReference = MessageReference.parse(messageReferenceString)
+
+ if (messageReference == null) {
+ Timber.w("Invalid message reference: %s", messageReferenceString)
+ return
+ }
+
+ val spamFolderId = account.spamFolderId
+ if (spamFolderId == null) {
+ Timber.w("No spam folder configured")
+ return
+ }
+
+ if (!K9.isConfirmSpam && messagingController.isMoveCapable(account)) {
+ val sourceFolderId = messageReference.folderId
+ messagingController.moveMessage(account, sourceFolderId, messageReference, spamFolderId)
+ }
+ }
+
+ private fun cancelNotifications(intent: Intent, account: Account) {
+ if (intent.hasExtra(EXTRA_MESSAGE_REFERENCE)) {
+ val messageReferenceString = intent.getStringExtra(EXTRA_MESSAGE_REFERENCE)
+ val messageReference = MessageReference.parse(messageReferenceString)
+
+ if (messageReference != null) {
+ messagingController.cancelNotificationForMessage(account, messageReference)
+ } else {
+ Timber.w("Invalid message reference: %s", messageReferenceString)
+ }
+ } else if (intent.hasExtra(EXTRA_MESSAGE_REFERENCES)) {
+ val messageReferenceStrings = intent.getStringArrayListExtra(EXTRA_MESSAGE_REFERENCES)
+ val messageReferences = MessageReferenceHelper.toMessageReferenceList(messageReferenceStrings)
+
+ for (messageReference in messageReferences) {
+ messagingController.cancelNotificationForMessage(account, messageReference)
+ }
+ } else {
+ messagingController.cancelNotificationsForAccount(account)
+ }
+ }
+
+ companion object {
+ private const val ACTION_MARK_AS_READ = "ACTION_MARK_AS_READ"
+ private const val ACTION_DELETE = "ACTION_DELETE"
+ private const val ACTION_ARCHIVE = "ACTION_ARCHIVE"
+ private const val ACTION_SPAM = "ACTION_SPAM"
+ private const val ACTION_DISMISS = "ACTION_DISMISS"
+ private const val EXTRA_ACCOUNT_UUID = "accountUuid"
+ private const val EXTRA_MESSAGE_REFERENCE = "messageReference"
+ private const val EXTRA_MESSAGE_REFERENCES = "messageReferences"
+
+ fun createMarkMessageAsReadIntent(context: Context, messageReference: MessageReference): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_MARK_AS_READ
+ putExtra(EXTRA_ACCOUNT_UUID, messageReference.accountUuid)
+ putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference))
+ }
+ }
+
+ fun createMarkAllAsReadIntent(
+ context: Context,
+ accountUuid: String,
+ messageReferences: List
+ ): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_MARK_AS_READ
+ putExtra(EXTRA_ACCOUNT_UUID, accountUuid)
+ putExtra(
+ EXTRA_MESSAGE_REFERENCES,
+ MessageReferenceHelper.toMessageReferenceStringList(messageReferences)
+ )
+ }
+ }
+
+ fun createDismissMessageIntent(context: Context, messageReference: MessageReference): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_DISMISS
+ putExtra(EXTRA_ACCOUNT_UUID, messageReference.accountUuid)
+ putExtra(EXTRA_MESSAGE_REFERENCE, messageReference.toIdentityString())
+ }
+ }
+
+ fun createDismissAllMessagesIntent(context: Context, account: Account): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_DISMISS
+ putExtra(EXTRA_ACCOUNT_UUID, account.uuid)
+ }
+ }
+
+ fun createDeleteMessageIntent(context: Context, messageReference: MessageReference): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_DELETE
+ putExtra(EXTRA_ACCOUNT_UUID, messageReference.accountUuid)
+ putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference))
+ }
+ }
+
+ fun createDeleteAllMessagesIntent(
+ context: Context,
+ accountUuid: String,
+ messageReferences: List
+ ): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_DELETE
+ putExtra(EXTRA_ACCOUNT_UUID, accountUuid)
+ putExtra(
+ EXTRA_MESSAGE_REFERENCES,
+ MessageReferenceHelper.toMessageReferenceStringList(messageReferences)
+ )
+ }
+ }
+
+ fun createArchiveMessageIntent(context: Context, messageReference: MessageReference): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_ARCHIVE
+ putExtra(EXTRA_ACCOUNT_UUID, messageReference.accountUuid)
+ putExtra(EXTRA_MESSAGE_REFERENCES, createSingleItemArrayList(messageReference))
+ }
+ }
+
+ fun createArchiveAllIntent(
+ context: Context,
+ account: Account,
+ messageReferences: List
+ ): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_ARCHIVE
+ putExtra(EXTRA_ACCOUNT_UUID, account.uuid)
+ putExtra(
+ EXTRA_MESSAGE_REFERENCES,
+ MessageReferenceHelper.toMessageReferenceStringList(messageReferences)
+ )
+ }
+ }
+
+ fun createMarkMessageAsSpamIntent(context: Context, messageReference: MessageReference): Intent {
+ return Intent(context, NotificationActionService::class.java).apply {
+ action = ACTION_SPAM
+ putExtra(EXTRA_ACCOUNT_UUID, messageReference.accountUuid)
+ putExtra(EXTRA_MESSAGE_REFERENCE, messageReference.toIdentityString())
+ }
+ }
+
+ private fun createSingleItemArrayList(messageReference: MessageReference): ArrayList {
+ return ArrayList(1).apply {
+ add(messageReference.toIdentityString())
+ }
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
index 71c2e728e980ddc40ecc921fd26ad10aabeca6fb..9597b082d5cb3e3d387e6b6d5748fee11838ea5a 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
@@ -6,8 +6,10 @@ import android.app.NotificationManager
import android.os.Build
import androidx.annotation.RequiresApi
import com.fsck.k9.Account
+import com.fsck.k9.NotificationSetting
import com.fsck.k9.Preferences
import java.util.concurrent.Executor
+import timber.log.Timber
class NotificationChannelManager(
private val preferences: Preferences,
@@ -137,12 +139,91 @@ class NotificationChannelManager(
}
fun getChannelIdFor(account: Account, channelType: ChannelType): String {
- val accountUuid = account.uuid
-
return if (channelType == ChannelType.MESSAGES) {
- "messages_channel_$accountUuid"
+ "messages_channel_${account.uuid}${account.messagesNotificationChannelSuffix}"
} else {
- "miscellaneous_channel_$accountUuid"
+ "miscellaneous_channel_${account.uuid}"
+ }
+ }
+
+ @RequiresApi(Build.VERSION_CODES.O)
+ fun getNotificationConfiguration(account: Account): NotificationConfiguration {
+ val channelId = getChannelIdFor(account, ChannelType.MESSAGES)
+ val notificationChannel = notificationManager.getNotificationChannel(channelId)
+
+ return NotificationConfiguration(
+ isBlinkLightsEnabled = notificationChannel.shouldShowLights(),
+ lightColor = notificationChannel.lightColor,
+ isVibrationEnabled = notificationChannel.shouldVibrate(),
+ vibrationPattern = notificationChannel.vibrationPattern?.toList()
+ )
+ }
+
+ fun recreateMessagesNotificationChannel(account: Account) {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+
+ val oldChannelId = getChannelIdFor(account, ChannelType.MESSAGES)
+ val oldNotificationChannel = notificationManager.getNotificationChannel(oldChannelId)
+
+ if (oldNotificationChannel.matches(account.notificationSetting)) {
+ Timber.v("Not recreating NotificationChannel. The current one already matches the app's settings.")
+ return
+ }
+
+ notificationManager.deleteNotificationChannel(oldChannelId)
+
+ account.incrementMessagesNotificationChannelVersion()
+
+ val newChannelId = getChannelIdFor(account, ChannelType.MESSAGES)
+ val channelName = resourceProvider.messagesChannelName
+ val importance = oldNotificationChannel.importance
+
+ val newNotificationChannel = NotificationChannel(newChannelId, channelName, importance).apply {
+ description = resourceProvider.messagesChannelDescription
+ group = account.uuid
+
+ copyPropertiesFrom(oldNotificationChannel)
+ copyPropertiesFrom(account.notificationSetting)
+ }
+
+ Timber.v("Recreating NotificationChannel(%s => %s)", oldChannelId, newChannelId)
+ notificationManager.createNotificationChannel(newNotificationChannel)
+ }
+
+ @RequiresApi(Build.VERSION_CODES.O)
+ private fun NotificationChannel.matches(notificationSetting: NotificationSetting): Boolean {
+ return lightColor == notificationSetting.ledColor &&
+ vibrationPattern.contentEquals(notificationSetting.vibration)
+ }
+
+ @RequiresApi(Build.VERSION_CODES.O)
+ private fun NotificationChannel.copyPropertiesFrom(otherNotificationChannel: NotificationChannel) {
+ setShowBadge(otherNotificationChannel.canShowBadge())
+ setSound(otherNotificationChannel.sound, otherNotificationChannel.audioAttributes)
+ enableVibration(otherNotificationChannel.shouldVibrate())
+ enableLights(otherNotificationChannel.shouldShowLights())
+ setBypassDnd(otherNotificationChannel.canBypassDnd())
+ lockscreenVisibility = otherNotificationChannel.lockscreenVisibility
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ setAllowBubbles(otherNotificationChannel.canBubble())
}
}
+
+ @RequiresApi(Build.VERSION_CODES.O)
+ private fun NotificationChannel.copyPropertiesFrom(notificationSetting: NotificationSetting) {
+ lightColor = notificationSetting.ledColor
+ if (shouldVibrate()) {
+ vibrationPattern = notificationSetting.vibration
+ }
+ }
+
+ private val Account.messagesNotificationChannelSuffix: String
+ get() = messagesNotificationChannelVersion.let { version -> if (version == 0) "" else "_$version" }
}
+
+data class NotificationConfiguration(
+ val isBlinkLightsEnabled: Boolean,
+ val lightColor: Int,
+ val isVibrationEnabled: Boolean,
+ val vibrationPattern: List?
+)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.java
deleted file mode 100644
index f3dc8cca4813e298ad9dfb3c740e3de214e96325..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import com.fsck.k9.controller.MessageReference;
-
-
-class NotificationContent {
- public final MessageReference messageReference;
- public final String sender;
- public final String subject;
- public final CharSequence preview;
- public final CharSequence summary;
- public final boolean starred;
-
-
- public NotificationContent(MessageReference messageReference, String sender, String subject, CharSequence preview,
- CharSequence summary, boolean starred) {
- this.messageReference = messageReference;
- this.sender = sender;
- this.subject = subject;
- this.preview = preview;
- this.summary = summary;
- this.starred = starred;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..374979d2e101a7d45b7a878d7d0244b1646bf318
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationContent.kt
@@ -0,0 +1,11 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.controller.MessageReference
+
+internal data class NotificationContent(
+ val messageReference: MessageReference,
+ val sender: String,
+ val subject: String,
+ val preview: CharSequence,
+ val summary: CharSequence
+)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.java
deleted file mode 100644
index 6d98f508f3533c23831805fe400758ef7b37baeb..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.content.Context;
-import android.text.SpannableStringBuilder;
-import android.text.TextUtils;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.K9;
-import com.fsck.k9.controller.MessageReference;
-import com.fsck.k9.helper.Contacts;
-import com.fsck.k9.helper.MessageHelper;
-import com.fsck.k9.mail.Address;
-import com.fsck.k9.mail.Flag;
-import com.fsck.k9.mail.Message;
-import com.fsck.k9.mailstore.LocalMessage;
-import com.fsck.k9.message.extractors.PreviewResult.PreviewType;
-
-
-class NotificationContentCreator {
- private final Context context;
- private final NotificationResourceProvider resourceProvider;
-
-
- public NotificationContentCreator(Context context, NotificationResourceProvider resourceProvider) {
- this.context = context;
- this.resourceProvider = resourceProvider;
- }
-
- public NotificationContent createFromMessage(Account account, LocalMessage message) {
- MessageReference messageReference = message.makeMessageReference();
- String sender = getMessageSender(account, message);
- String displaySender = getMessageSenderForDisplay(sender);
- String subject = getMessageSubject(message);
- CharSequence preview = getMessagePreview(message);
- CharSequence summary = buildMessageSummary(sender, subject);
- boolean starred = message.isSet(Flag.FLAGGED);
-
- return new NotificationContent(messageReference, displaySender, subject, preview, summary, starred);
- }
-
- private CharSequence getMessagePreview(LocalMessage message) {
- String subject = message.getSubject();
- String snippet = getPreview(message);
-
- boolean isSubjectEmpty = TextUtils.isEmpty(subject);
- boolean isSnippetPresent = snippet != null;
- if (isSubjectEmpty && isSnippetPresent) {
- return snippet;
- }
-
- String displaySubject = getMessageSubject(message);
-
- SpannableStringBuilder preview = new SpannableStringBuilder();
- preview.append(displaySubject);
- if (isSnippetPresent) {
- preview.append('\n');
- preview.append(snippet);
- }
-
- return preview;
- }
-
- private String getPreview(LocalMessage message) {
- PreviewType previewType = message.getPreviewType();
- switch (previewType) {
- case NONE:
- case ERROR:
- return null;
- case TEXT:
- return message.getPreview();
- case ENCRYPTED:
- return resourceProvider.previewEncrypted();
- }
-
- throw new AssertionError("Unknown preview type: " + previewType);
- }
-
- private CharSequence buildMessageSummary(String sender, String subject) {
- if (sender == null) {
- return subject;
- }
-
- SpannableStringBuilder summary = new SpannableStringBuilder();
- summary.append(sender);
- summary.append(" ");
- summary.append(subject);
-
- return summary;
- }
-
- private String getMessageSubject(Message message) {
- String subject = message.getSubject();
- if (!TextUtils.isEmpty(subject)) {
- return subject;
- }
-
- return resourceProvider.noSubject();
- }
-
- private String getMessageSender(Account account, Message message) {
- boolean isSelf = false;
- final Contacts contacts = K9.isShowContactName() ? Contacts.getInstance(context) : null;
- final Address[] fromAddresses = message.getFrom();
-
- if (fromAddresses != null) {
- isSelf = account.isAnIdentity(fromAddresses);
- if (!isSelf && fromAddresses.length > 0) {
- return MessageHelper.toFriendly(fromAddresses[0], contacts).toString();
- }
- }
-
- if (isSelf) {
- // show To: if the message was sent from me
- Address[] recipients = message.getRecipients(Message.RecipientType.TO);
-
- if (recipients != null && recipients.length > 0) {
- String recipientDisplayName = MessageHelper.toFriendly(recipients[0], contacts).toString();
- return resourceProvider.recipientDisplayName(recipientDisplayName);
- }
- }
-
- return null;
- }
-
- private String getMessageSenderForDisplay(String sender) {
- return (sender != null) ? sender : resourceProvider.noSender();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..86d85b8efa8e3e81e06f079752228d61a40d2286
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationContentCreator.kt
@@ -0,0 +1,99 @@
+package com.fsck.k9.notification
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import com.fsck.k9.Account
+import com.fsck.k9.K9
+import com.fsck.k9.helper.Contacts
+import com.fsck.k9.helper.MessageHelper
+import com.fsck.k9.mail.Message
+import com.fsck.k9.mailstore.LocalMessage
+import com.fsck.k9.message.extractors.PreviewResult.PreviewType
+
+internal class NotificationContentCreator(
+ private val context: Context,
+ private val resourceProvider: NotificationResourceProvider
+) {
+ fun createFromMessage(account: Account, message: LocalMessage): NotificationContent {
+ val sender = getMessageSender(account, message)
+
+ return NotificationContent(
+ messageReference = message.makeMessageReference(),
+ sender = getMessageSenderForDisplay(sender),
+ subject = getMessageSubject(message),
+ preview = getMessagePreview(message),
+ summary = buildMessageSummary(sender, getMessageSubject(message))
+ )
+ }
+
+ private fun getMessagePreview(message: LocalMessage): CharSequence {
+ val snippet = getPreview(message)
+ if (message.subject.isNullOrEmpty() && snippet != null) {
+ return snippet
+ }
+
+ return SpannableStringBuilder().apply {
+ val displaySubject = getMessageSubject(message)
+ append(displaySubject)
+
+ if (snippet != null) {
+ append('\n')
+ append(snippet)
+ }
+ }
+ }
+
+ private fun getPreview(message: LocalMessage): String? {
+ val previewType = message.previewType ?: error("previewType == null")
+ return when (previewType) {
+ PreviewType.NONE, PreviewType.ERROR -> null
+ PreviewType.TEXT -> message.preview
+ PreviewType.ENCRYPTED -> resourceProvider.previewEncrypted()
+ }
+ }
+
+ private fun buildMessageSummary(sender: String?, subject: String): CharSequence {
+ return if (sender == null) {
+ subject
+ } else {
+ SpannableStringBuilder().apply {
+ append(sender)
+ append(" ")
+ append(subject)
+ }
+ }
+ }
+
+ private fun getMessageSubject(message: Message): String {
+ val subject = message.subject.orEmpty()
+ return subject.ifEmpty { resourceProvider.noSubject() }
+ }
+
+ private fun getMessageSender(account: Account, message: Message): String? {
+ val contacts = if (K9.isShowContactName) Contacts.getInstance(context) else null
+ var isSelf = false
+
+ val fromAddresses = message.from
+ if (!fromAddresses.isNullOrEmpty()) {
+ isSelf = account.isAnIdentity(fromAddresses)
+ if (!isSelf) {
+ return MessageHelper.toFriendly(fromAddresses.first(), contacts).toString()
+ }
+ }
+
+ if (isSelf) {
+ // show To: if the message was sent from me
+ val recipients = message.getRecipients(Message.RecipientType.TO)
+ if (!recipients.isNullOrEmpty()) {
+ val recipientDisplayName = MessageHelper.toFriendly(recipients.first(), contacts).toString()
+ return resourceProvider.recipientDisplayName(recipientDisplayName)
+ }
+ }
+
+ return null
+ }
+
+ private fun getMessageSenderForDisplay(sender: String?): String {
+ return sender ?: resourceProvider.noSender()
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationController.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationController.java
deleted file mode 100644
index 1426f3e6f5953ee9ecba0d57ecc9a3fb8dc60da1..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationController.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import com.fsck.k9.Account;
-import com.fsck.k9.controller.MessageReference;
-import com.fsck.k9.mailstore.LocalFolder;
-import com.fsck.k9.mailstore.LocalMessage;
-
-
-public class NotificationController {
- private final CertificateErrorNotifications certificateErrorNotifications;
- private final AuthenticationErrorNotifications authenticationErrorNotifications;
- private final SyncNotifications syncNotifications;
- private final SendFailedNotifications sendFailedNotifications;
- private final NewMailNotifications newMailNotifications;
-
-
- NotificationController(
- CertificateErrorNotifications certificateErrorNotifications,
- AuthenticationErrorNotifications authenticationErrorNotifications,
- SyncNotifications syncNotifications,
- SendFailedNotifications sendFailedNotifications,
- NewMailNotifications newMailNotifications
- ) {
- this.certificateErrorNotifications = certificateErrorNotifications;
- this.authenticationErrorNotifications = authenticationErrorNotifications;
- this.syncNotifications = syncNotifications;
- this.sendFailedNotifications = sendFailedNotifications;
- this.newMailNotifications = newMailNotifications;
- }
-
- public void showCertificateErrorNotification(Account account, boolean incoming) {
- certificateErrorNotifications.showCertificateErrorNotification(account, incoming);
- }
-
- public void clearCertificateErrorNotifications(Account account, boolean incoming) {
- certificateErrorNotifications.clearCertificateErrorNotifications(account, incoming);
- }
-
- public void showAuthenticationErrorNotification(Account account, boolean incoming) {
- authenticationErrorNotifications.showAuthenticationErrorNotification(account, incoming);
- }
-
- public void clearAuthenticationErrorNotification(Account account, boolean incoming) {
- authenticationErrorNotifications.clearAuthenticationErrorNotification(account, incoming);
- }
-
- public void showSendingNotification(Account account) {
- syncNotifications.showSendingNotification(account);
- }
-
- public void clearSendingNotification(Account account) {
- syncNotifications.clearSendingNotification(account);
- }
-
- public void showSendFailedNotification(Account account, Exception exception) {
- sendFailedNotifications.showSendFailedNotification(account, exception);
- }
-
- public void clearSendFailedNotification(Account account) {
- sendFailedNotifications.clearSendFailedNotification(account);
- }
-
- public void showFetchingMailNotification(Account account, LocalFolder folder) {
- syncNotifications.showFetchingMailNotification(account, folder);
- }
-
- public void clearFetchingMailNotification(Account account) {
- syncNotifications.clearFetchingMailNotification(account);
- }
-
- public void addNewMailNotification(Account account, LocalMessage message, int previousUnreadMessageCount) {
- newMailNotifications.addNewMailNotification(account, message, previousUnreadMessageCount);
- }
-
- public void removeNewMailNotification(Account account, MessageReference messageReference) {
- newMailNotifications.removeNewMailNotification(account, messageReference);
- }
-
- public void clearNewMailNotifications(Account account) {
- newMailNotifications.clearNewMailNotifications(account);
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fe0144108e8d4c800d930123bb743c28811318d4
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationController.kt
@@ -0,0 +1,80 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.mailstore.LocalFolder
+import com.fsck.k9.mailstore.LocalMessage
+
+class NotificationController internal constructor(
+ private val certificateErrorNotificationController: CertificateErrorNotificationController,
+ private val authenticationErrorNotificationController: AuthenticationErrorNotificationController,
+ private val syncNotificationController: SyncNotificationController,
+ private val sendFailedNotificationController: SendFailedNotificationController,
+ private val newMailNotificationController: NewMailNotificationController
+) {
+ fun showCertificateErrorNotification(account: Account, incoming: Boolean) {
+ certificateErrorNotificationController.showCertificateErrorNotification(account, incoming)
+ }
+
+ fun clearCertificateErrorNotifications(account: Account, incoming: Boolean) {
+ certificateErrorNotificationController.clearCertificateErrorNotifications(account, incoming)
+ }
+
+ fun showAuthenticationErrorNotification(account: Account, incoming: Boolean) {
+ authenticationErrorNotificationController.showAuthenticationErrorNotification(account, incoming)
+ }
+
+ fun clearAuthenticationErrorNotification(account: Account, incoming: Boolean) {
+ authenticationErrorNotificationController.clearAuthenticationErrorNotification(account, incoming)
+ }
+
+ fun showSendingNotification(account: Account) {
+ syncNotificationController.showSendingNotification(account)
+ }
+
+ fun clearSendingNotification(account: Account) {
+ syncNotificationController.clearSendingNotification(account)
+ }
+
+ fun showSendFailedNotification(account: Account, exception: Exception) {
+ sendFailedNotificationController.showSendFailedNotification(account, exception)
+ }
+
+ fun clearSendFailedNotification(account: Account) {
+ sendFailedNotificationController.clearSendFailedNotification(account)
+ }
+
+ fun showFetchingMailNotification(account: Account, folder: LocalFolder) {
+ syncNotificationController.showFetchingMailNotification(account, folder)
+ }
+
+ fun showEmptyFetchingMailNotification(account: Account) {
+ syncNotificationController.showEmptyFetchingMailNotification(account)
+ }
+
+ fun clearFetchingMailNotification(account: Account) {
+ syncNotificationController.clearFetchingMailNotification(account)
+ }
+
+ fun restoreNewMailNotifications(accounts: List) {
+ newMailNotificationController.restoreNewMailNotifications(accounts)
+ }
+
+ fun addNewMailNotification(account: Account, message: LocalMessage, silent: Boolean) {
+ newMailNotificationController.addNewMailNotification(account, message, silent)
+ }
+
+ fun removeNewMailNotification(account: Account, messageReference: MessageReference) {
+ newMailNotificationController.removeNewMailNotifications(account, clearNewMessageState = true) {
+ listOf(messageReference)
+ }
+ }
+
+ fun clearNewMailNotifications(account: Account, selector: (List) -> List) {
+ newMailNotificationController.removeNewMailNotifications(account, clearNewMessageState = false, selector)
+ }
+
+ fun clearNewMailNotifications(account: Account, clearNewMessageState: Boolean) {
+ newMailNotificationController.clearNewMailNotifications(account, clearNewMessageState)
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationData.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationData.java
deleted file mode 100644
index 69475eaa204306241f38cca2f45ec6465a691cc1..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationData.java
+++ /dev/null
@@ -1,224 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import android.util.SparseBooleanArray;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.controller.MessageReference;
-
-
-/**
- * A holder class for pending new mail notifications.
- */
-class NotificationData {
- // Note: As of Jellybean, phone notifications show a maximum of 5 lines, while tablet notifications show 7 lines.
- static final int MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION = 5;
- // Note: This class assumes MAX_NUMBER_OF_STACKED_NOTIFICATIONS >= MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION
- static final int MAX_NUMBER_OF_STACKED_NOTIFICATIONS = 8;
-
-
- private final Account account;
- private final LinkedList activeNotifications = new LinkedList<>();
- private final Deque additionalNotifications = new LinkedList<>();
- private final SparseBooleanArray notificationIdsInUse = new SparseBooleanArray();
- private int unreadMessageCount;
-
-
- public NotificationData(Account account) {
- this.account = account;
- }
-
- public AddNotificationResult addNotificationContent(NotificationContent content) {
- int notificationId;
- boolean cancelNotificationIdBeforeReuse;
- if (isMaxNumberOfActiveNotificationsReached()) {
- NotificationHolder notificationHolder = activeNotifications.removeLast();
- addToAdditionalNotifications(notificationHolder);
- notificationId = notificationHolder.notificationId;
- cancelNotificationIdBeforeReuse = true;
- } else {
- notificationId = getNewNotificationId();
- cancelNotificationIdBeforeReuse = false;
- }
-
- NotificationHolder notificationHolder = createNotificationHolder(notificationId, content);
- activeNotifications.addFirst(notificationHolder);
-
- if (cancelNotificationIdBeforeReuse) {
- return AddNotificationResult.replaceNotification(notificationHolder);
- } else {
- return AddNotificationResult.newNotification(notificationHolder);
- }
- }
-
- private boolean isMaxNumberOfActiveNotificationsReached() {
- return activeNotifications.size() == MAX_NUMBER_OF_STACKED_NOTIFICATIONS;
- }
-
- private void addToAdditionalNotifications(NotificationHolder notificationHolder) {
- additionalNotifications.addFirst(notificationHolder.content);
- }
-
- private int getNewNotificationId() {
- for (int i = 0; i < MAX_NUMBER_OF_STACKED_NOTIFICATIONS; i++) {
- int notificationId = NotificationIds.getNewMailStackedNotificationId(account, i);
- if (!isNotificationInUse(notificationId)) {
- markNotificationIdAsInUse(notificationId);
- return notificationId;
- }
- }
-
- throw new AssertionError("getNewNotificationId() called with no free notification ID");
- }
-
- private boolean isNotificationInUse(int notificationId) {
- return notificationIdsInUse.get(notificationId);
- }
-
- private void markNotificationIdAsInUse(int notificationId) {
- notificationIdsInUse.put(notificationId, true);
- }
-
- private void markNotificationIdAsFree(int notificationId) {
- notificationIdsInUse.delete(notificationId);
- }
-
- NotificationHolder createNotificationHolder(int notificationId, NotificationContent content) {
- return new NotificationHolder(notificationId, content);
- }
-
- public boolean containsStarredMessages() {
- for (NotificationHolder holder : activeNotifications) {
- if (holder.content.starred) {
- return true;
- }
- }
-
- for (NotificationContent content : additionalNotifications) {
- if (content.starred) {
- return true;
- }
- }
-
- return false;
- }
-
- public boolean hasSummaryOverflowMessages() {
- return activeNotifications.size() > MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION;
- }
-
- public int getSummaryOverflowMessagesCount() {
- int activeOverflowCount = activeNotifications.size() - MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION;
- if (activeOverflowCount > 0) {
- return activeOverflowCount + additionalNotifications.size();
- }
- return additionalNotifications.size();
- }
-
- public int getNewMessagesCount() {
- return activeNotifications.size() + additionalNotifications.size();
- }
-
- public boolean isSingleMessageNotification() {
- return activeNotifications.size() == 1;
- }
-
- public NotificationHolder getHolderForLatestNotification() {
- return activeNotifications.getFirst();
- }
-
- public List getContentForSummaryNotification() {
- int size = calculateNumberOfMessagesForSummaryNotification();
- List result = new ArrayList<>(size);
-
- Iterator iterator = activeNotifications.iterator();
- int notificationCount = 0;
- while (iterator.hasNext() && notificationCount < MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION) {
- NotificationHolder holder = iterator.next();
- result.add(holder.content);
- notificationCount++;
- }
-
- return result;
- }
-
- private int calculateNumberOfMessagesForSummaryNotification() {
- return Math.min(activeNotifications.size(), MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION);
- }
-
- public int[] getActiveNotificationIds() {
- int size = activeNotifications.size();
- int[] notificationIds = new int[size];
-
- for (int i = 0; i < size; i++) {
- NotificationHolder holder = activeNotifications.get(i);
- notificationIds[i] = holder.notificationId;
- }
-
- return notificationIds;
- }
-
- public RemoveNotificationResult removeNotificationForMessage(MessageReference messageReference) {
- NotificationHolder holder = getNotificationHolderForMessage(messageReference);
- if (holder == null) {
- return RemoveNotificationResult.unknownNotification();
- }
-
- activeNotifications.remove(holder);
-
- int notificationId = holder.notificationId;
- markNotificationIdAsFree(notificationId);
-
- if (!additionalNotifications.isEmpty()) {
- NotificationContent newContent = additionalNotifications.removeFirst();
- NotificationHolder replacement = createNotificationHolder(notificationId, newContent);
- activeNotifications.addLast(replacement);
- return RemoveNotificationResult.createNotification(replacement);
- }
-
- return RemoveNotificationResult.cancelNotification(notificationId);
- }
-
- private NotificationHolder getNotificationHolderForMessage(MessageReference messageReference) {
- for (NotificationHolder holder : activeNotifications) {
- if (messageReference.equals(holder.content.messageReference)) {
- return holder;
- }
- }
-
- return null;
- }
-
- public Account getAccount() {
- return account;
- }
-
- public int getUnreadMessageCount() {
- return unreadMessageCount + getNewMessagesCount();
- }
-
- public void setUnreadMessageCount(int unreadMessageCount) {
- this.unreadMessageCount = unreadMessageCount;
- }
-
- public ArrayList getAllMessageReferences() {
- int newSize = activeNotifications.size() + additionalNotifications.size();
- ArrayList messageReferences = new ArrayList<>(newSize);
-
- for (NotificationHolder holder : activeNotifications) {
- messageReferences.add(holder.content.messageReference);
- }
-
- for (NotificationContent content : additionalNotifications) {
- messageReferences.add(content.messageReference);
- }
-
- return messageReferences;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationData.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationData.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c50985022b2d6637b5d28276eb9dc1e0d1823a02
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationData.kt
@@ -0,0 +1,40 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+
+/**
+ * Holds information about active and inactive new message notifications of an account.
+ */
+internal data class NotificationData(
+ val account: Account,
+ val activeNotifications: List,
+ val inactiveNotifications: List
+) {
+ val newMessagesCount: Int
+ get() = activeNotifications.size + inactiveNotifications.size
+
+ val isSingleMessageNotification: Boolean
+ get() = activeNotifications.size == 1
+
+ @OptIn(ExperimentalStdlibApi::class)
+ val messageReferences: List
+ get() {
+ return buildList(capacity = newMessagesCount) {
+ for (activeNotification in activeNotifications) {
+ add(activeNotification.content.messageReference)
+ }
+ for (inactiveNotification in inactiveNotifications) {
+ add(inactiveNotification.content.messageReference)
+ }
+ }
+ }
+
+ fun isEmpty() = activeNotifications.isEmpty()
+
+ companion object {
+ fun create(account: Account): NotificationData {
+ return NotificationData(account, activeNotifications = emptyList(), inactiveNotifications = emptyList())
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationDataStore.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationDataStore.kt
new file mode 100644
index 0000000000000000000000000000000000000000..51372b0a939d6c83d1815b49d19aff957ce0e443
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationDataStore.kt
@@ -0,0 +1,177 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+
+internal const val MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS = 8
+
+/**
+ * Stores information about new message notifications for all accounts.
+ *
+ * We only use a limited number of system notifications per account (see [MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS]);
+ * those are called active notifications. The rest are called inactive notifications. When an active notification is
+ * removed, the latest inactive notification is promoted to an active notification.
+ */
+internal class NotificationDataStore {
+ private val notificationDataMap = mutableMapOf()
+
+ @Synchronized
+ fun initializeAccount(
+ account: Account,
+ activeNotifications: List,
+ inactiveNotifications: List
+ ): NotificationData {
+ require(activeNotifications.size <= MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS)
+
+ return NotificationData(account, activeNotifications, inactiveNotifications).also { notificationData ->
+ notificationDataMap[account.uuid] = notificationData
+ }
+ }
+
+ @Synchronized
+ fun addNotification(account: Account, content: NotificationContent, timestamp: Long): AddNotificationResult {
+ val notificationData = getNotificationData(account)
+
+ return if (notificationData.isMaxNumberOfActiveNotificationsReached) {
+ val lastNotificationHolder = notificationData.activeNotifications.last()
+ val inactiveNotificationHolder = lastNotificationHolder.toInactiveNotificationHolder()
+
+ val notificationId = lastNotificationHolder.notificationId
+ val notificationHolder = NotificationHolder(notificationId, timestamp, content)
+
+ val operations = listOf(
+ NotificationStoreOperation.ChangeToInactive(lastNotificationHolder.content.messageReference),
+ NotificationStoreOperation.Add(content.messageReference, notificationId, timestamp)
+ )
+
+ val newNotificationData = notificationData.copy(
+ activeNotifications = listOf(notificationHolder) + notificationData.activeNotifications.dropLast(1),
+ inactiveNotifications = listOf(inactiveNotificationHolder) + notificationData.inactiveNotifications
+ )
+ notificationDataMap[account.uuid] = newNotificationData
+
+ AddNotificationResult.replaceNotification(newNotificationData, operations, notificationHolder)
+ } else {
+ val notificationId = notificationData.getNewNotificationId()
+ val notificationHolder = NotificationHolder(notificationId, timestamp, content)
+
+ val operations = listOf(
+ NotificationStoreOperation.Add(content.messageReference, notificationId, timestamp)
+ )
+
+ val newNotificationData = notificationData.copy(
+ activeNotifications = listOf(notificationHolder) + notificationData.activeNotifications
+ )
+ notificationDataMap[account.uuid] = newNotificationData
+
+ AddNotificationResult.newNotification(newNotificationData, operations, notificationHolder)
+ }
+ }
+
+ @Synchronized
+ fun removeNotifications(
+ account: Account,
+ selector: (List) -> List
+ ): RemoveNotificationsResult? {
+ val notificationData = getNotificationData(account)
+ if (notificationData.isEmpty()) return null
+
+ val removeMessageReferences = selector.invoke(notificationData.messageReferences)
+
+ val operations = mutableListOf()
+ val newNotificationHolders = mutableListOf()
+ val cancelNotificationIds = mutableListOf()
+
+ for (messageReference in removeMessageReferences) {
+ val notificationHolder = notificationData.activeNotifications.firstOrNull {
+ it.content.messageReference == messageReference
+ }
+
+ if (notificationHolder == null) {
+ val inactiveNotificationHolder = notificationData.inactiveNotifications.firstOrNull {
+ it.content.messageReference == messageReference
+ } ?: continue
+
+ operations.add(NotificationStoreOperation.Remove(messageReference))
+
+ val newNotificationData = notificationData.copy(
+ inactiveNotifications = notificationData.inactiveNotifications - inactiveNotificationHolder
+ )
+ notificationDataMap[account.uuid] = newNotificationData
+ } else if (notificationData.inactiveNotifications.isNotEmpty()) {
+ val newNotificationHolder = notificationData.inactiveNotifications.first()
+ .toNotificationHolder(notificationHolder.notificationId)
+
+ newNotificationHolders.add(newNotificationHolder)
+ cancelNotificationIds.add(notificationHolder.notificationId)
+
+ operations.add(NotificationStoreOperation.Remove(messageReference))
+ operations.add(
+ NotificationStoreOperation.ChangeToActive(
+ newNotificationHolder.content.messageReference,
+ newNotificationHolder.notificationId
+ )
+ )
+
+ val newNotificationData = notificationData.copy(
+ activeNotifications = notificationData.activeNotifications - notificationHolder +
+ newNotificationHolder,
+ inactiveNotifications = notificationData.inactiveNotifications.drop(1)
+ )
+ notificationDataMap[account.uuid] = newNotificationData
+ } else {
+ cancelNotificationIds.add(notificationHolder.notificationId)
+
+ operations.add(NotificationStoreOperation.Remove(messageReference))
+
+ val newNotificationData = notificationData.copy(
+ activeNotifications = notificationData.activeNotifications - notificationHolder
+ )
+ notificationDataMap[account.uuid] = newNotificationData
+ }
+ }
+
+ return if (operations.isEmpty()) {
+ null
+ } else {
+ RemoveNotificationsResult(
+ notificationData = getNotificationData(account),
+ notificationStoreOperations = operations,
+ notificationHolders = newNotificationHolders,
+ cancelNotificationIds = cancelNotificationIds
+ )
+ }
+ }
+
+ @Synchronized
+ fun clearNotifications(account: Account) {
+ notificationDataMap.remove(account.uuid)
+ }
+
+ private fun getNotificationData(account: Account): NotificationData {
+ return notificationDataMap[account.uuid] ?: NotificationData.create(account).also { notificationData ->
+ notificationDataMap[account.uuid] = notificationData
+ }
+ }
+
+ private val NotificationData.isMaxNumberOfActiveNotificationsReached: Boolean
+ get() = activeNotifications.size == MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS
+
+ private fun NotificationData.getNewNotificationId(): Int {
+ val notificationIdsInUse = activeNotifications.map { it.notificationId }.toSet()
+ for (index in 0 until MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS) {
+ val notificationId = NotificationIds.getSingleMessageNotificationId(account, index)
+ if (notificationId !in notificationIdsInUse) {
+ return notificationId
+ }
+ }
+
+ throw AssertionError("getNewNotificationId() called with no free notification ID")
+ }
+
+ private fun NotificationHolder.toInactiveNotificationHolder() = InactiveNotificationHolder(timestamp, content)
+
+ private fun InactiveNotificationHolder.toNotificationHolder(notificationId: Int): NotificationHolder {
+ return NotificationHolder(notificationId, timestamp, content)
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.java
deleted file mode 100644
index 7d95f50feba1d58247470108c2691ae3afccf2e5..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import com.fsck.k9.Account;
-
-
-public class NotificationGroupKeys {
- private static final String NOTIFICATION_GROUP_KEY_PREFIX = "newMailNotifications-";
-
-
- public static String getGroupKey(Account account) {
- return NOTIFICATION_GROUP_KEY_PREFIX + account.getAccountNumber();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1f53762bbc49bfd350541524127cab7e78aa3f62
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationGroupKeys.kt
@@ -0,0 +1,11 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+
+object NotificationGroupKeys {
+ private const val NOTIFICATION_GROUP_KEY_PREFIX = "newMailNotifications-"
+
+ fun getGroupKey(account: Account): String {
+ return NOTIFICATION_GROUP_KEY_PREFIX + account.accountNumber
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationHelper.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationHelper.kt
index 606edc184e65006599dc6703c46eaa0a6454148d..9199fa7ad08dd15ac8700c9c2ff05639d55084b4 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationHelper.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationHelper.kt
@@ -23,6 +23,7 @@ class NotificationHelper(
) {
if (K9.isQuietTime) {
+ builder.setNotificationSilent()
return
}
@@ -34,6 +35,8 @@ class NotificationHelper(
if (vibrationPattern != null) {
builder.setVibrate(vibrationPattern)
}
+ } else {
+ builder.setNotificationSilent()
}
if (ledColor != null) {
@@ -75,8 +78,8 @@ class NotificationHelper(
}
companion object {
- private const val NOTIFICATION_LED_ON_TIME = 500
- private const val NOTIFICATION_LED_OFF_TIME = 2000
+ internal const val NOTIFICATION_LED_ON_TIME = 500
+ internal const val NOTIFICATION_LED_OFF_TIME = 2000
private const val NOTIFICATION_LED_FAST_ON_TIME = 100
private const val NOTIFICATION_LED_FAST_OFF_TIME = 100
@@ -85,3 +88,28 @@ class NotificationHelper(
internal const val NOTIFICATION_LED_FAILURE_COLOR = -0x10000
}
}
+
+internal fun NotificationCompat.Builder.setAppearance(
+ silent: Boolean,
+ appearance: NotificationAppearance
+): NotificationCompat.Builder = apply {
+ if (silent) {
+ setSilent(true)
+ } else {
+ if (!appearance.ringtone.isNullOrEmpty()) {
+ setSound(Uri.parse(appearance.ringtone))
+ }
+
+ if (appearance.vibrationPattern != null) {
+ setVibrate(appearance.vibrationPattern)
+ }
+
+ if (appearance.ledColor != null) {
+ setLights(
+ appearance.ledColor,
+ NotificationHelper.NOTIFICATION_LED_ON_TIME,
+ NotificationHelper.NOTIFICATION_LED_OFF_TIME
+ )
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.java
deleted file mode 100644
index b1acf555fbaa4f078a1645a81bfc63ff7eeb8964..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.fsck.k9.notification;
-
-
-class NotificationHolder {
- public final int notificationId;
- public final NotificationContent content;
-
-
- public NotificationHolder(int notificationId, NotificationContent content) {
- this.notificationId = notificationId;
- this.content = content;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.kt
new file mode 100644
index 0000000000000000000000000000000000000000..73a3647a18cbb1c7ff27286fad062e066c44cc19
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationHolder.kt
@@ -0,0 +1,12 @@
+package com.fsck.k9.notification
+
+internal data class NotificationHolder(
+ val notificationId: Int,
+ val timestamp: Long,
+ val content: NotificationContent
+)
+
+internal data class InactiveNotificationHolder(
+ val timestamp: Long,
+ val content: NotificationContent
+)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.java b/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.java
deleted file mode 100644
index e74d7de2f3fd06fbdeec382126b4e2565ab22230..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import com.fsck.k9.Account;
-
-
-class NotificationIds {
- public static final int PUSH_NOTIFICATION_ID = 1;
- private static final int NUMBER_OF_GENERAL_NOTIFICATIONS = 1;
-
- private static final int OFFSET_SEND_FAILED_NOTIFICATION = 0;
- private static final int OFFSET_CERTIFICATE_ERROR_INCOMING = 1;
- private static final int OFFSET_CERTIFICATE_ERROR_OUTGOING = 2;
- private static final int OFFSET_AUTHENTICATION_ERROR_INCOMING = 3;
- private static final int OFFSET_AUTHENTICATION_ERROR_OUTGOING = 4;
- private static final int OFFSET_FETCHING_MAIL = 5;
- private static final int OFFSET_NEW_MAIL_SUMMARY = 6;
-
- private static final int OFFSET_NEW_MAIL_STACKED = 7;
-
- private static final int NUMBER_OF_DEVICE_NOTIFICATIONS = 7;
- private static final int NUMBER_OF_STACKED_NOTIFICATIONS = NotificationData.MAX_NUMBER_OF_STACKED_NOTIFICATIONS;
- private static final int NUMBER_OF_NOTIFICATIONS_PER_ACCOUNT = NUMBER_OF_DEVICE_NOTIFICATIONS +
- NUMBER_OF_STACKED_NOTIFICATIONS;
-
-
- public static int getNewMailSummaryNotificationId(Account account) {
- return getBaseNotificationId(account) + OFFSET_NEW_MAIL_SUMMARY;
- }
-
- public static int getNewMailStackedNotificationId(Account account, int index) {
- if (index < 0 || index >= NUMBER_OF_STACKED_NOTIFICATIONS) {
- throw new IndexOutOfBoundsException("Invalid value: " + index);
- }
-
- return getBaseNotificationId(account) + OFFSET_NEW_MAIL_STACKED + index;
- }
-
- public static int getFetchingMailNotificationId(Account account) {
- return getBaseNotificationId(account) + OFFSET_FETCHING_MAIL;
- }
-
- public static int getSendFailedNotificationId(Account account) {
- return getBaseNotificationId(account) + OFFSET_SEND_FAILED_NOTIFICATION;
- }
-
- public static int getCertificateErrorNotificationId(Account account, boolean incoming) {
- int offset = incoming ? OFFSET_CERTIFICATE_ERROR_INCOMING : OFFSET_CERTIFICATE_ERROR_OUTGOING;
- return getBaseNotificationId(account) + offset;
- }
-
- public static int getAuthenticationErrorNotificationId(Account account, boolean incoming) {
- int offset = incoming ? OFFSET_AUTHENTICATION_ERROR_INCOMING : OFFSET_AUTHENTICATION_ERROR_OUTGOING;
- return getBaseNotificationId(account) + offset;
- }
-
- private static int getBaseNotificationId(Account account) {
- return 1 /* skip notification ID 0 */ + NUMBER_OF_GENERAL_NOTIFICATIONS +
- account.getAccountNumber() * NUMBER_OF_NOTIFICATIONS_PER_ACCOUNT;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a074c61774b8d3299f890213de8c5e9d9ea7895a
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt
@@ -0,0 +1,64 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+
+internal object NotificationIds {
+ const val PUSH_NOTIFICATION_ID = 1
+
+ private const val NUMBER_OF_GENERAL_NOTIFICATIONS = 1
+ private const val OFFSET_SEND_FAILED_NOTIFICATION = 0
+ private const val OFFSET_CERTIFICATE_ERROR_INCOMING = 1
+ private const val OFFSET_CERTIFICATE_ERROR_OUTGOING = 2
+ private const val OFFSET_AUTHENTICATION_ERROR_INCOMING = 3
+ private const val OFFSET_AUTHENTICATION_ERROR_OUTGOING = 4
+ private const val OFFSET_FETCHING_MAIL = 5
+ private const val OFFSET_NEW_MAIL_SUMMARY = 6
+ private const val OFFSET_NEW_MAIL_SINGLE = 7
+ private const val NUMBER_OF_MISC_ACCOUNT_NOTIFICATIONS = 7
+ private const val NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS = MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS
+ private const val NUMBER_OF_NOTIFICATIONS_PER_ACCOUNT =
+ NUMBER_OF_MISC_ACCOUNT_NOTIFICATIONS + NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS
+
+ fun getNewMailSummaryNotificationId(account: Account): Int {
+ return getBaseNotificationId(account) + OFFSET_NEW_MAIL_SUMMARY
+ }
+
+ fun getSingleMessageNotificationId(account: Account, index: Int): Int {
+ require(index in 0 until NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS) { "Invalid index: $index" }
+
+ return getBaseNotificationId(account) + OFFSET_NEW_MAIL_SINGLE + index
+ }
+
+ fun getAllMessageNotificationIds(account: Account): List {
+ val singleMessageNotificationIdRange = (0 until NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS) +
+ (getBaseNotificationId(account) + OFFSET_NEW_MAIL_SINGLE)
+
+ return singleMessageNotificationIdRange.toList() + getNewMailSummaryNotificationId(account)
+ }
+
+ fun getFetchingMailNotificationId(account: Account): Int {
+ return getBaseNotificationId(account) + OFFSET_FETCHING_MAIL
+ }
+
+ fun getSendFailedNotificationId(account: Account): Int {
+ return getBaseNotificationId(account) + OFFSET_SEND_FAILED_NOTIFICATION
+ }
+
+
+ fun getCertificateErrorNotificationId(account: Account, incoming: Boolean): Int {
+ val offset = if (incoming) OFFSET_CERTIFICATE_ERROR_INCOMING else OFFSET_CERTIFICATE_ERROR_OUTGOING
+
+ return getBaseNotificationId(account) + offset
+ }
+
+ fun getAuthenticationErrorNotificationId(account: Account, incoming: Boolean): Int {
+ val offset = if (incoming) OFFSET_AUTHENTICATION_ERROR_INCOMING else OFFSET_AUTHENTICATION_ERROR_OUTGOING
+
+ return getBaseNotificationId(account) + offset
+ }
+
+ private fun getBaseNotificationId(account: Account): Int {
+ return 1 /* skip notification ID 0 */ + NUMBER_OF_GENERAL_NOTIFICATIONS +
+ account.accountNumber * NUMBER_OF_NOTIFICATIONS_PER_ACCOUNT
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationRepository.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b18f3686aa7259b3179e3482ad0d55fdff644f86
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationRepository.kt
@@ -0,0 +1,111 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.controller.MessageReference
+import com.fsck.k9.mailstore.LocalStoreProvider
+import com.fsck.k9.mailstore.MessageStoreManager
+
+internal class NotificationRepository(
+ private val notificationStoreProvider: NotificationStoreProvider,
+ private val localStoreProvider: LocalStoreProvider,
+ private val messageStoreManager: MessageStoreManager,
+ private val notificationContentCreator: NotificationContentCreator
+) {
+ private val notificationDataStore = NotificationDataStore()
+
+ @Synchronized
+ fun restoreNotifications(account: Account): NotificationData? {
+ val localStore = localStoreProvider.getInstance(account)
+
+ val (activeNotificationMessages, inactiveNotificationMessages) = localStore.notificationMessages.partition {
+ it.notificationId != null
+ }
+
+ if (activeNotificationMessages.isEmpty()) return null
+
+ val activeNotifications = activeNotificationMessages.map { notificationMessage ->
+ val content = notificationContentCreator.createFromMessage(account, notificationMessage.message)
+ NotificationHolder(notificationMessage.notificationId!!, notificationMessage.timestamp, content)
+ }
+
+ val inactiveNotifications = inactiveNotificationMessages.map { notificationMessage ->
+ val content = notificationContentCreator.createFromMessage(account, notificationMessage.message)
+ InactiveNotificationHolder(notificationMessage.timestamp, content)
+ }
+
+ return notificationDataStore.initializeAccount(account, activeNotifications, inactiveNotifications)
+ }
+
+ @Synchronized
+ fun addNotification(account: Account, content: NotificationContent, timestamp: Long): AddNotificationResult {
+ return notificationDataStore.addNotification(account, content, timestamp).also { result ->
+ persistNotificationDataStoreChanges(account, result.notificationStoreOperations)
+ }
+ }
+
+ @Synchronized
+ fun removeNotifications(
+ account: Account,
+ clearNewMessageState: Boolean = true,
+ selector: (List) -> List
+ ): RemoveNotificationsResult? {
+ return notificationDataStore.removeNotifications(account, selector)?.also { result ->
+ if (clearNewMessageState) {
+ persistNotificationDataStoreChanges(account, result.notificationStoreOperations)
+ }
+ }
+ }
+
+ @Synchronized
+ fun clearNotifications(account: Account, clearNewMessageState: Boolean) {
+ notificationDataStore.clearNotifications(account)
+ clearNotificationStore(account)
+
+ if (clearNewMessageState) {
+ clearNewMessageState(account)
+ }
+ }
+
+ private fun persistNotificationDataStoreChanges(account: Account, operations: List) {
+ val notificationStore = notificationStoreProvider.getNotificationStore(account)
+ notificationStore.persistNotificationChanges(operations)
+
+ setNewMessageState(account, operations)
+ }
+
+ private fun setNewMessageState(account: Account, operations: List) {
+ val messageStore = messageStoreManager.getMessageStore(account)
+
+ for (operation in operations) {
+ when (operation) {
+ is NotificationStoreOperation.Add -> {
+ val messageReference = operation.messageReference
+ messageStore.setNewMessageState(
+ folderId = messageReference.folderId,
+ messageServerId = messageReference.uid,
+ newMessage = true
+ )
+ }
+ is NotificationStoreOperation.Remove -> {
+ val messageReference = operation.messageReference
+ messageStore.setNewMessageState(
+ folderId = messageReference.folderId,
+ messageServerId = messageReference.uid,
+ newMessage = false
+ )
+ }
+ else -> Unit
+ }
+ }
+ }
+
+ private fun clearNewMessageState(account: Account) {
+ val messageStore = messageStoreManager.getMessageStore(account)
+ messageStore.clearNewMessageState()
+ }
+
+ private fun clearNotificationStore(account: Account) {
+ val notificationStore = notificationStoreProvider.getNotificationStore(account)
+ notificationStore.clearNotifications()
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
index adc9eb8f4d9e9d3d2b80f620eabcce46e2dd1343..e558cd5e74e25f26d33cf12bb235fe5daa5bb4ab 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
@@ -24,6 +24,7 @@ interface NotificationResourceProvider {
fun authenticationErrorTitle(): String
fun authenticationErrorBody(accountName: String): String
+ fun certificateErrorTitle(): String
fun certificateErrorTitle(accountName: String): String
fun certificateErrorBody(): String
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationStore.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationStore.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4068bad6ffd7036bec6bfd936853b58635bce61b
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationStore.kt
@@ -0,0 +1,6 @@
+package com.fsck.k9.notification
+
+interface NotificationStore {
+ fun persistNotificationChanges(operations: List)
+ fun clearNotifications()
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreOperation.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreOperation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c03620fba3df31cd01837b0ab59fb938bdb3db74
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreOperation.kt
@@ -0,0 +1,20 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.controller.MessageReference
+
+sealed interface NotificationStoreOperation {
+ data class Add(
+ val messageReference: MessageReference,
+ val notificationId: Int,
+ val timestamp: Long
+ ) : NotificationStoreOperation
+
+ data class Remove(val messageReference: MessageReference) : NotificationStoreOperation
+
+ data class ChangeToInactive(val messageReference: MessageReference) : NotificationStoreOperation
+
+ data class ChangeToActive(
+ val messageReference: MessageReference,
+ val notificationId: Int
+ ) : NotificationStoreOperation
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreProvider.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..44d04096375e6695b4ba4ecd834e9fb720e406ca
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationStoreProvider.kt
@@ -0,0 +1,7 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+
+interface NotificationStoreProvider {
+ fun getNotificationStore(account: Account): NotificationStore
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/PushNotificationManager.kt b/app/core/src/main/java/com/fsck/k9/notification/PushNotificationManager.kt
index c26f7899acf688b66361b2149f464a44ead40183..bd15f47801b7afb7f7d57bbed2db8af025e83ee0 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/PushNotificationManager.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/PushNotificationManager.kt
@@ -64,6 +64,7 @@ internal class PushNotificationManager(
.setContentIntent(contentIntent)
.setOngoing(true)
.setNotificationSilent()
+ .setPriority(NotificationCompat.PRIORITY_MIN)
.setBadgeIconType(NotificationCompat.BADGE_ICON_NONE)
.setLocalOnly(true)
.setShowWhen(false)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationResult.java b/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationResult.java
deleted file mode 100644
index 7b57b0442c96d56afbe9d19e0a7262782b003b2c..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationResult.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package com.fsck.k9.notification;
-
-
-class RemoveNotificationResult {
- private final NotificationHolder notificationHolder;
- private final int notificationId;
- private final boolean unknownNotification;
-
-
- private RemoveNotificationResult(NotificationHolder notificationHolder, int notificationId,
- boolean unknownNotification) {
- this.notificationHolder = notificationHolder;
- this.notificationId = notificationId;
- this.unknownNotification = unknownNotification;
- }
-
- public static RemoveNotificationResult createNotification(NotificationHolder notificationHolder) {
- return new RemoveNotificationResult(notificationHolder, notificationHolder.notificationId, false);
- }
-
- public static RemoveNotificationResult cancelNotification(int notificationId) {
- return new RemoveNotificationResult(null, notificationId, false);
- }
-
- public static RemoveNotificationResult unknownNotification() {
- return new RemoveNotificationResult(null, 0, true);
- }
-
- public boolean shouldCreateNotification() {
- return notificationHolder != null;
- }
-
- public int getNotificationId() {
- if (isUnknownNotification()) {
- throw new IllegalStateException("getNotificationId() can only be called when " +
- "isUnknownNotification() returns false");
- }
-
- return notificationId;
- }
-
- public boolean isUnknownNotification() {
- return unknownNotification;
- }
-
- public NotificationHolder getNotificationHolder() {
- if (!shouldCreateNotification()) {
- throw new IllegalStateException("getNotificationHolder() can only be called when " +
- "shouldCreateNotification() returns true");
- }
-
- return notificationHolder;
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationsResult.kt b/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationsResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f3c2d44bffafb34c002104ece3a081cb9bf9a050
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/RemoveNotificationsResult.kt
@@ -0,0 +1,8 @@
+package com.fsck.k9.notification
+
+internal data class RemoveNotificationsResult(
+ val notificationData: NotificationData,
+ val notificationStoreOperations: List,
+ val notificationHolders: List,
+ val cancelNotificationIds: List
+)
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..067893a8e2ad1193b3864e6b76e33d892117224f
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotificationController.kt
@@ -0,0 +1,66 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.Account
+import com.fsck.k9.helper.ExceptionHelper
+
+internal class SendFailedNotificationController(
+ private val notificationHelper: NotificationHelper,
+ private val actionBuilder: NotificationActionCreator,
+ private val resourceProvider: NotificationResourceProvider
+) {
+ fun showSendFailedNotification(account: Account, exception: Exception) {
+ val title = resourceProvider.sendFailedTitle()
+ val text = ExceptionHelper.getRootCauseMessage(exception)
+
+ val notificationId = NotificationIds.getSendFailedNotificationId(account)
+ val folderListPendingIntent = actionBuilder.createViewFolderListPendingIntent(
+ account, notificationId
+ )
+
+ val notificationBuilder = notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setAutoCancel(true)
+ .setTicker(title)
+ .setContentTitle(title)
+ .setContentText(text)
+ .setContentIntent(folderListPendingIntent)
+ .setStyle(NotificationCompat.BigTextStyle().bigText(text))
+ .setPublicVersion(createLockScreenNotification(account))
+ .setCategory(NotificationCompat.CATEGORY_ERROR)
+
+ notificationHelper.configureNotification(
+ builder = notificationBuilder,
+ ringtone = null,
+ vibrationPattern = null,
+ ledColor = NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR,
+ ledSpeed = NotificationHelper.NOTIFICATION_LED_BLINK_FAST,
+ ringAndVibrate = true
+ )
+
+ notificationManager.notify(notificationId, notificationBuilder.build())
+ }
+
+ fun clearSendFailedNotification(account: Account) {
+ val notificationId = NotificationIds.getSendFailedNotificationId(account)
+ notificationManager.cancel(notificationId)
+ }
+
+ private fun createLockScreenNotification(account: Account): Notification {
+ return notificationHelper
+ .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
+ .setSmallIcon(resourceProvider.iconWarning)
+ .setColor(account.chipColor)
+ .setWhen(System.currentTimeMillis())
+ .setContentTitle(resourceProvider.sendFailedTitle())
+ .build()
+ }
+
+ private val notificationManager: NotificationManagerCompat
+ get() = notificationHelper.getNotificationManager()
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotifications.java b/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotifications.java
deleted file mode 100644
index 2bb63cd5e94b79106f7a4968fb59d35d220916a4..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/notification/SendFailedNotifications.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package com.fsck.k9.notification;
-
-
-import android.app.PendingIntent;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationCompat.BigTextStyle;
-import androidx.core.app.NotificationManagerCompat;
-
-import com.fsck.k9.Account;
-import com.fsck.k9.helper.ExceptionHelper;
-
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_BLINK_FAST;
-import static com.fsck.k9.notification.NotificationHelper.NOTIFICATION_LED_FAILURE_COLOR;
-
-
-class SendFailedNotifications {
- private final NotificationHelper notificationHelper;
- private final NotificationActionCreator actionBuilder;
- private final NotificationResourceProvider resourceProvider;
-
-
- public SendFailedNotifications(NotificationHelper notificationHelper, NotificationActionCreator actionBuilder,
- NotificationResourceProvider resourceProvider) {
- this.notificationHelper = notificationHelper;
- this.actionBuilder = actionBuilder;
- this.resourceProvider = resourceProvider;
- }
-
- public void showSendFailedNotification(Account account, Exception exception) {
- String title = resourceProvider.sendFailedTitle();
- String text = ExceptionHelper.getRootCauseMessage(exception);
-
- int notificationId = NotificationIds.getSendFailedNotificationId(account);
- PendingIntent folderListPendingIntent = actionBuilder.createViewFolderListPendingIntent(
- account, notificationId);
-
- NotificationCompat.Builder builder = notificationHelper
- .createNotificationBuilder(account, NotificationChannelManager.ChannelType.MISCELLANEOUS)
- .setSmallIcon(resourceProvider.getIconWarning())
- .setWhen(System.currentTimeMillis())
- .setAutoCancel(true)
- .setTicker(title)
- .setContentTitle(title)
- .setContentText(text)
- .setContentIntent(folderListPendingIntent)
- .setStyle(new BigTextStyle().bigText(text))
- .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
- .setCategory(NotificationCompat.CATEGORY_ERROR);
-
- notificationHelper.configureNotification(builder, null, null, NOTIFICATION_LED_FAILURE_COLOR,
- NOTIFICATION_LED_BLINK_FAST, true);
-
- getNotificationManager().notify(notificationId, builder.build());
- }
-
- public void clearSendFailedNotification(Account account) {
- int notificationId = NotificationIds.getSendFailedNotificationId(account);
- getNotificationManager().cancel(notificationId);
- }
-
- private NotificationManagerCompat getNotificationManager() {
- return notificationHelper.getNotificationManager();
- }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..46635307a418863fb74749631861464da3d8384b
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationCreator.kt
@@ -0,0 +1,185 @@
+package com.fsck.k9.notification
+
+import android.app.PendingIntent
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationCompat.WearableExtender
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.notification.NotificationChannelManager.ChannelType
+import androidx.core.app.NotificationCompat.Builder as NotificationBuilder
+
+internal class SingleMessageNotificationCreator(
+ private val notificationHelper: NotificationHelper,
+ private val actionCreator: NotificationActionCreator,
+ private val resourceProvider: NotificationResourceProvider,
+ private val lockScreenNotificationCreator: LockScreenNotificationCreator,
+ private val notificationManager: NotificationManagerCompat
+) {
+ fun createSingleNotification(
+ baseNotificationData: BaseNotificationData,
+ singleNotificationData: SingleNotificationData,
+ isGroupSummary: Boolean = false
+ ) {
+ val account = baseNotificationData.account
+ val notificationId = singleNotificationData.notificationId
+ val content = singleNotificationData.content
+
+ val notification = notificationHelper.createNotificationBuilder(account, ChannelType.MESSAGES)
+ .setCategory(NotificationCompat.CATEGORY_EMAIL)
+ .setAutoCancel(true)
+ .setGroup(baseNotificationData.groupKey)
+ .setGroupSummary(isGroupSummary)
+ .setSmallIcon(resourceProvider.iconNewMail)
+ .setColor(baseNotificationData.color)
+ .setWhen(singleNotificationData.timestamp)
+ .setTicker(content.summary)
+ .setContentTitle(content.sender)
+ .setContentText(content.subject)
+ .setSubText(baseNotificationData.accountName)
+ .setBigText(content.preview)
+ .setContentIntent(createViewIntent(content, notificationId))
+ .setDeleteIntent(createDismissIntent(content, notificationId))
+ .setDeviceActions(singleNotificationData)
+ .setWearActions(singleNotificationData)
+ .setAppearance(singleNotificationData.isSilent, baseNotificationData.appearance)
+ .setLockScreenNotification(baseNotificationData, singleNotificationData.addLockScreenNotification)
+ .build()
+
+ notificationManager.notify(notificationId, notification)
+ }
+
+ private fun NotificationBuilder.setBigText(text: CharSequence) = apply {
+ setStyle(NotificationCompat.BigTextStyle().bigText(text))
+ }
+
+ private fun createViewIntent(content: NotificationContent, notificationId: Int): PendingIntent {
+ return actionCreator.createViewMessagePendingIntent(content.messageReference, notificationId)
+ }
+
+ private fun createDismissIntent(content: NotificationContent, notificationId: Int): PendingIntent {
+ return actionCreator.createDismissMessagePendingIntent(content.messageReference, notificationId)
+ }
+
+ private fun NotificationBuilder.setDeviceActions(notificationData: SingleNotificationData) = apply {
+ val actions = notificationData.actions
+ for (action in actions) {
+ when (action) {
+ NotificationAction.Reply -> addReplyAction(notificationData)
+ NotificationAction.MarkAsRead -> addMarkAsReadAction(notificationData)
+ NotificationAction.Delete -> addDeleteAction(notificationData)
+ }
+ }
+ }
+
+ private fun NotificationBuilder.addReplyAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.iconReply
+ val title = resourceProvider.actionReply()
+ val content = notificationData.content
+ val messageReference = content.messageReference
+ val replyToMessagePendingIntent =
+ actionCreator.createReplyPendingIntent(messageReference, notificationData.notificationId)
+
+ addAction(icon, title, replyToMessagePendingIntent)
+ }
+
+ private fun NotificationBuilder.addMarkAsReadAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.iconMarkAsRead
+ val title = resourceProvider.actionMarkAsRead()
+ val content = notificationData.content
+ val notificationId = notificationData.notificationId
+ val messageReference = content.messageReference
+ val action = actionCreator.createMarkMessageAsReadPendingIntent(messageReference, notificationId)
+
+ addAction(icon, title, action)
+ }
+
+ private fun NotificationBuilder.addDeleteAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.iconDelete
+ val title = resourceProvider.actionDelete()
+ val content = notificationData.content
+ val notificationId = notificationData.notificationId
+ val messageReference = content.messageReference
+ val action = actionCreator.createDeleteMessagePendingIntent(messageReference, notificationId)
+
+ addAction(icon, title, action)
+ }
+
+ private fun NotificationBuilder.setWearActions(notificationData: SingleNotificationData) = apply {
+ val wearableExtender = WearableExtender().apply {
+ for (action in notificationData.wearActions) {
+ when (action) {
+ WearNotificationAction.Reply -> addReplyAction(notificationData)
+ WearNotificationAction.MarkAsRead -> addMarkAsReadAction(notificationData)
+ WearNotificationAction.Delete -> addDeleteAction(notificationData)
+ WearNotificationAction.Archive -> addArchiveAction(notificationData)
+ WearNotificationAction.Spam -> addMarkAsSpamAction(notificationData)
+ }
+ }
+ }
+
+ extend(wearableExtender)
+ }
+
+ private fun WearableExtender.addReplyAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.wearIconReplyAll
+ val title = resourceProvider.actionReply()
+ val messageReference = notificationData.content.messageReference
+ val notificationId = notificationData.notificationId
+ val action = actionCreator.createReplyPendingIntent(messageReference, notificationId)
+ val replyAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(replyAction)
+ }
+
+ private fun WearableExtender.addMarkAsReadAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.wearIconMarkAsRead
+ val title = resourceProvider.actionMarkAsRead()
+ val messageReference = notificationData.content.messageReference
+ val notificationId = notificationData.notificationId
+ val action = actionCreator.createMarkMessageAsReadPendingIntent(messageReference, notificationId)
+ val markAsReadAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(markAsReadAction)
+ }
+
+ private fun WearableExtender.addDeleteAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.wearIconDelete
+ val title = resourceProvider.actionDelete()
+ val messageReference = notificationData.content.messageReference
+ val notificationId = notificationData.notificationId
+ val action = actionCreator.createDeleteMessagePendingIntent(messageReference, notificationId)
+ val deleteAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(deleteAction)
+ }
+
+ private fun WearableExtender.addArchiveAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.wearIconArchive
+ val title = resourceProvider.actionArchive()
+ val messageReference = notificationData.content.messageReference
+ val notificationId = notificationData.notificationId
+ val action = actionCreator.createArchiveMessagePendingIntent(messageReference, notificationId)
+ val archiveAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(archiveAction)
+ }
+
+ private fun WearableExtender.addMarkAsSpamAction(notificationData: SingleNotificationData) {
+ val icon = resourceProvider.wearIconMarkAsSpam
+ val title = resourceProvider.actionMarkAsSpam()
+ val messageReference = notificationData.content.messageReference
+ val notificationId = notificationData.notificationId
+ val action = actionCreator.createMarkMessageAsSpamPendingIntent(messageReference, notificationId)
+ val spamAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(spamAction)
+ }
+
+ private fun NotificationBuilder.setLockScreenNotification(
+ notificationData: BaseNotificationData,
+ addLockScreenNotification: Boolean
+ ) = apply {
+ if (addLockScreenNotification) {
+ lockScreenNotificationCreator.configureLockScreenNotification(this, notificationData)
+ }
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationDataCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationDataCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c9012752fbca9f0dfc46a3341371ff14e311d22c
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/SingleMessageNotificationDataCreator.kt
@@ -0,0 +1,89 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.K9
+
+internal class SingleMessageNotificationDataCreator {
+
+ fun createSingleNotificationData(
+ account: Account,
+ notificationId: Int,
+ content: NotificationContent,
+ timestamp: Long,
+ addLockScreenNotification: Boolean
+ ): SingleNotificationData {
+ return SingleNotificationData(
+ notificationId = notificationId,
+ isSilent = true,
+ timestamp = timestamp,
+ content = content,
+ actions = createSingleNotificationActions(),
+ wearActions = createSingleNotificationWearActions(account),
+ addLockScreenNotification = addLockScreenNotification
+ )
+ }
+
+ fun createSummarySingleNotificationData(
+ data: NotificationData,
+ timestamp: Long,
+ silent: Boolean
+ ): SummarySingleNotificationData {
+ return SummarySingleNotificationData(
+ SingleNotificationData(
+ notificationId = NotificationIds.getNewMailSummaryNotificationId(data.account),
+ isSilent = silent,
+ timestamp = timestamp,
+ content = data.activeNotifications.first().content,
+ actions = createSingleNotificationActions(),
+ wearActions = createSingleNotificationWearActions(data.account),
+ addLockScreenNotification = false,
+ ),
+ )
+ }
+
+ @OptIn(ExperimentalStdlibApi::class)
+ private fun createSingleNotificationActions(): List {
+ return buildList {
+ add(NotificationAction.Reply)
+ add(NotificationAction.MarkAsRead)
+
+ if (isDeleteActionEnabled()) {
+ add(NotificationAction.Delete)
+ }
+ }
+ }
+
+ @OptIn(ExperimentalStdlibApi::class)
+ private fun createSingleNotificationWearActions(account: Account): List {
+ return buildList {
+ add(WearNotificationAction.Reply)
+ add(WearNotificationAction.MarkAsRead)
+
+ if (isDeleteActionAvailableForWear()) {
+ add(WearNotificationAction.Delete)
+ }
+
+ if (account.hasArchiveFolder()) {
+ add(WearNotificationAction.Archive)
+ }
+
+ if (isSpamActionAvailableForWear(account)) {
+ add(WearNotificationAction.Spam)
+ }
+ }
+ }
+
+ private fun isDeleteActionEnabled(): Boolean {
+ return K9.notificationQuickDeleteBehaviour != K9.NotificationQuickDelete.NEVER
+ }
+
+ // We don't support confirming actions on Wear devices. So don't show the action when confirmation is enabled.
+ private fun isDeleteActionAvailableForWear(): Boolean {
+ return isDeleteActionEnabled() && !K9.isConfirmDeleteFromNotification
+ }
+
+ // We don't support confirming actions on Wear devices. So don't show the action when confirmation is enabled.
+ private fun isSpamActionAvailableForWear(account: Account): Boolean {
+ return account.hasSpamFolder() && !K9.isConfirmSpam
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d6b85a3aef2bb2e41718d2e71d16fad9fbf7a5cb
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationCreator.kt
@@ -0,0 +1,210 @@
+package com.fsck.k9.notification
+
+import android.app.PendingIntent
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationCompat.WearableExtender
+import androidx.core.app.NotificationManagerCompat
+import com.fsck.k9.Account
+import com.fsck.k9.notification.NotificationChannelManager.ChannelType
+import com.fsck.k9.notification.NotificationIds.getNewMailSummaryNotificationId
+import androidx.core.app.NotificationCompat.Builder as NotificationBuilder
+
+internal class SummaryNotificationCreator(
+ private val notificationHelper: NotificationHelper,
+ private val actionCreator: NotificationActionCreator,
+ private val lockScreenNotificationCreator: LockScreenNotificationCreator,
+ private val singleMessageNotificationCreator: SingleMessageNotificationCreator,
+ private val resourceProvider: NotificationResourceProvider,
+ private val notificationManager: NotificationManagerCompat
+) {
+ fun createSummaryNotification(
+ baseNotificationData: BaseNotificationData,
+ summaryNotificationData: SummaryNotificationData
+ ) {
+ when (summaryNotificationData) {
+ is SummarySingleNotificationData -> {
+ createSingleMessageNotification(baseNotificationData, summaryNotificationData.singleNotificationData)
+ }
+ is SummaryInboxNotificationData -> {
+ createInboxStyleSummaryNotification(baseNotificationData, summaryNotificationData)
+ }
+ }
+ }
+
+ private fun createSingleMessageNotification(
+ baseNotificationData: BaseNotificationData,
+ singleNotificationData: SingleNotificationData
+ ) {
+ singleMessageNotificationCreator.createSingleNotification(
+ baseNotificationData,
+ singleNotificationData,
+ isGroupSummary = true
+ )
+ }
+
+ private fun createInboxStyleSummaryNotification(
+ baseNotificationData: BaseNotificationData,
+ notificationData: SummaryInboxNotificationData
+ ) {
+ val account = baseNotificationData.account
+ val accountName = baseNotificationData.accountName
+ val newMessagesCount = baseNotificationData.newMessagesCount
+ val title = resourceProvider.newMessagesTitle(newMessagesCount)
+ val summary = buildInboxSummaryText(accountName, notificationData)
+
+ val notification = notificationHelper.createNotificationBuilder(account, ChannelType.MESSAGES)
+ .setCategory(NotificationCompat.CATEGORY_EMAIL)
+ .setAutoCancel(true)
+ .setGroup(baseNotificationData.groupKey)
+ .setGroupSummary(true)
+ .setSmallIcon(resourceProvider.iconNewMail)
+ .setColor(baseNotificationData.color)
+ .setWhen(notificationData.timestamp)
+ .setNumber(notificationData.additionalMessagesCount)
+ .setTicker(notificationData.content.firstOrNull())
+ .setContentTitle(title)
+ .setSubText(accountName)
+ .setInboxStyle(title, summary, notificationData.content)
+ .setContentIntent(createViewIntent(account, notificationData))
+ .setDeleteIntent(createDismissIntent(account, notificationData.notificationId))
+ .setDeviceActions(account, notificationData)
+ .setWearActions(account, notificationData)
+ .setAppearance(notificationData.isSilent, baseNotificationData.appearance)
+ .setLockScreenNotification(baseNotificationData)
+ .build()
+
+ notificationManager.notify(notificationData.notificationId, notification)
+ }
+
+ private fun buildInboxSummaryText(accountName: String, notificationData: SummaryInboxNotificationData): String {
+ return if (notificationData.additionalMessagesCount > 0) {
+ resourceProvider.additionalMessages(notificationData.additionalMessagesCount, accountName)
+ } else {
+ accountName
+ }
+ }
+
+ private fun NotificationBuilder.setInboxStyle(
+ title: String,
+ summary: String,
+ contentLines: List
+ ) = apply {
+ val style = NotificationCompat.InboxStyle()
+ .setBigContentTitle(title)
+ .setSummaryText(summary)
+
+ for (line in contentLines) {
+ style.addLine(line)
+ }
+
+ setStyle(style)
+ }
+
+ private fun createViewIntent(account: Account, notificationData: SummaryInboxNotificationData): PendingIntent {
+ return actionCreator.createViewMessagesPendingIntent(
+ account = account,
+ messageReferences = notificationData.messageReferences,
+ notificationId = notificationData.notificationId
+ )
+ }
+
+ private fun createDismissIntent(account: Account, notificationId: Int): PendingIntent {
+ return actionCreator.createDismissAllMessagesPendingIntent(account, notificationId)
+ }
+
+ private fun NotificationBuilder.setDeviceActions(
+ account: Account,
+ notificationData: SummaryInboxNotificationData
+ ) = apply {
+ for (action in notificationData.actions) {
+ when (action) {
+ SummaryNotificationAction.MarkAsRead -> addMarkAllAsReadAction(account, notificationData)
+ SummaryNotificationAction.Delete -> addDeleteAllAction(account, notificationData)
+ }
+ }
+ }
+
+ private fun NotificationBuilder.addMarkAllAsReadAction(
+ account: Account,
+ notificationData: SummaryInboxNotificationData
+ ) {
+ val icon = resourceProvider.iconMarkAsRead
+ val title = resourceProvider.actionMarkAsRead()
+ val messageReferences = notificationData.messageReferences
+ val notificationId = notificationData.notificationId
+ val markAllAsReadPendingIntent =
+ actionCreator.createMarkAllAsReadPendingIntent(account, messageReferences, notificationId)
+
+ addAction(icon, title, markAllAsReadPendingIntent)
+ }
+
+ private fun NotificationBuilder.addDeleteAllAction(
+ account: Account,
+ notificationData: SummaryInboxNotificationData
+ ) {
+ val icon = resourceProvider.iconDelete
+ val title = resourceProvider.actionDelete()
+ val notificationId = getNewMailSummaryNotificationId(account)
+ val messageReferences = notificationData.messageReferences
+ val action = actionCreator.createDeleteAllPendingIntent(account, messageReferences, notificationId)
+
+ addAction(icon, title, action)
+ }
+
+ private fun NotificationBuilder.setWearActions(
+ account: Account,
+ notificationData: SummaryInboxNotificationData
+ ) = apply {
+ val wearableExtender = WearableExtender().apply {
+ for (action in notificationData.wearActions) {
+ when (action) {
+ SummaryWearNotificationAction.MarkAsRead -> addMarkAllAsReadAction(account, notificationData)
+ SummaryWearNotificationAction.Delete -> addDeleteAllAction(account, notificationData)
+ SummaryWearNotificationAction.Archive -> addArchiveAllAction(account, notificationData)
+ }
+ }
+ }
+
+ extend(wearableExtender)
+ }
+
+ private fun WearableExtender.addMarkAllAsReadAction(
+ account: Account,
+ notificationData: SummaryInboxNotificationData
+ ) {
+ val icon = resourceProvider.wearIconMarkAsRead
+ val title = resourceProvider.actionMarkAllAsRead()
+ val messageReferences = notificationData.messageReferences
+ val notificationId = getNewMailSummaryNotificationId(account)
+ val action = actionCreator.createMarkAllAsReadPendingIntent(account, messageReferences, notificationId)
+ val markAsReadAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(markAsReadAction)
+ }
+
+ private fun WearableExtender.addDeleteAllAction(account: Account, notificationData: SummaryInboxNotificationData) {
+ val icon = resourceProvider.wearIconDelete
+ val title = resourceProvider.actionDeleteAll()
+ val messageReferences = notificationData.messageReferences
+ val notificationId = getNewMailSummaryNotificationId(account)
+ val action = actionCreator.createDeleteAllPendingIntent(account, messageReferences, notificationId)
+ val deleteAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(deleteAction)
+ }
+
+ private fun WearableExtender.addArchiveAllAction(account: Account, notificationData: SummaryInboxNotificationData) {
+ val icon = resourceProvider.wearIconArchive
+ val title = resourceProvider.actionArchiveAll()
+ val messageReferences = notificationData.messageReferences
+ val notificationId = getNewMailSummaryNotificationId(account)
+ val action = actionCreator.createArchiveAllPendingIntent(account, messageReferences, notificationId)
+ val archiveAction = NotificationCompat.Action.Builder(icon, title, action).build()
+
+ addAction(archiveAction)
+ }
+
+ private fun NotificationBuilder.setLockScreenNotification(notificationData: BaseNotificationData) = apply {
+ lockScreenNotificationCreator.configureLockScreenNotification(this, notificationData)
+ }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationDataCreator.kt b/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationDataCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..77e1272826515e46aaccca190d9bc1e62f82b56d
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/SummaryNotificationDataCreator.kt
@@ -0,0 +1,94 @@
+package com.fsck.k9.notification
+
+import com.fsck.k9.Account
+import com.fsck.k9.K9
+
+private const val MAX_NUMBER_OF_MESSAGES_FOR_SUMMARY_NOTIFICATION = 5
+
+internal class SummaryNotificationDataCreator(
+ private val singleMessageNotificationDataCreator: SingleMessageNotificationDataCreator
+) {
+ fun createSummaryNotificationData(data: NotificationData, silent: Boolean): SummaryNotificationData {
+ val timestamp = data.latestTimestamp
+ val shouldBeSilent = silent || K9.isQuietTime
+ return if (data.isSingleMessageNotification) {
+ createSummarySingleNotificationData(data, timestamp, shouldBeSilent)
+ } else {
+ createSummaryInboxNotificationData(data, timestamp, shouldBeSilent)
+ }
+ }
+
+ private fun createSummarySingleNotificationData(
+ data: NotificationData,
+ timestamp: Long,
+ silent: Boolean
+ ): SummaryNotificationData {
+ return singleMessageNotificationDataCreator.createSummarySingleNotificationData(data, timestamp, silent)
+ }
+
+ private fun createSummaryInboxNotificationData(
+ data: NotificationData,
+ timestamp: Long,
+ silent: Boolean
+ ): SummaryNotificationData {
+ return SummaryInboxNotificationData(
+ notificationId = NotificationIds.getNewMailSummaryNotificationId(data.account),
+ isSilent = silent,
+ timestamp = timestamp,
+ content = data.summaryContent,
+ additionalMessagesCount = data.additionalMessagesCount,
+ messageReferences = data.messageReferences,
+ actions = createSummaryNotificationActions(),
+ wearActions = createSummaryWearNotificationActions(data.account)
+ )
+ }
+
+ @OptIn(ExperimentalStdlibApi::class)
+ private fun createSummaryNotificationActions(): List