2018-08-02 13:33:06 +00:00
|
|
|
package eu.faircode.email;
|
|
|
|
|
|
|
|
/*
|
2018-08-14 05:53:24 +00:00
|
|
|
This file is part of FairEmail.
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-08-14 05:53:24 +00:00
|
|
|
FairEmail is free software: you can redistribute it and/or modify
|
2018-08-02 13:33:06 +00:00
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
2018-10-29 10:46:49 +00:00
|
|
|
FairEmail is distributed in the hope that it will be useful,
|
2018-08-02 13:33:06 +00:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2018-10-29 10:46:49 +00:00
|
|
|
along with FairEmail. If not, see <http://www.gnu.org/licenses/>.
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2021-01-01 07:56:36 +00:00
|
|
|
Copyright 2018-2021 by Marcel Bokhorst (M66B)
|
2018-08-02 13:33:06 +00:00
|
|
|
*/
|
|
|
|
|
2021-07-30 12:54:44 +00:00
|
|
|
import static android.os.Process.THREAD_PRIORITY_BACKGROUND;
|
|
|
|
|
2018-10-09 19:39:25 +00:00
|
|
|
import android.app.AlarmManager;
|
2018-08-02 13:33:06 +00:00
|
|
|
import android.app.NotificationManager;
|
|
|
|
import android.app.PendingIntent;
|
2021-09-02 21:06:59 +00:00
|
|
|
import android.appwidget.AppWidgetManager;
|
2018-08-02 13:33:06 +00:00
|
|
|
import android.content.BroadcastReceiver;
|
2021-09-02 21:06:59 +00:00
|
|
|
import android.content.ComponentName;
|
2018-08-02 13:33:06 +00:00
|
|
|
import android.content.Context;
|
|
|
|
import android.content.Intent;
|
|
|
|
import android.content.IntentFilter;
|
2018-09-14 13:31:00 +00:00
|
|
|
import android.content.SharedPreferences;
|
2018-08-02 13:33:06 +00:00
|
|
|
import android.net.ConnectivityManager;
|
2020-07-14 19:12:35 +00:00
|
|
|
import android.net.LinkProperties;
|
2018-08-02 13:33:06 +00:00
|
|
|
import android.net.Network;
|
|
|
|
import android.net.NetworkCapabilities;
|
|
|
|
import android.net.NetworkRequest;
|
|
|
|
import android.os.Build;
|
2019-12-09 21:26:29 +00:00
|
|
|
import android.os.Bundle;
|
2020-09-21 20:33:06 +00:00
|
|
|
import android.os.OperationCanceledException;
|
2018-10-08 06:18:44 +00:00
|
|
|
import android.os.PowerManager;
|
2019-10-01 07:20:05 +00:00
|
|
|
import android.text.TextUtils;
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
import androidx.annotation.NonNull;
|
2020-06-12 12:02:14 +00:00
|
|
|
import androidx.annotation.RequiresApi;
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.core.app.NotificationCompat;
|
|
|
|
import androidx.core.content.ContextCompat;
|
2019-12-06 15:00:11 +00:00
|
|
|
import androidx.lifecycle.MediatorLiveData;
|
|
|
|
import androidx.lifecycle.MutableLiveData;
|
2019-04-17 18:21:44 +00:00
|
|
|
import androidx.lifecycle.Observer;
|
|
|
|
import androidx.preference.PreferenceManager;
|
|
|
|
|
2020-12-02 13:39:48 +00:00
|
|
|
import com.sun.mail.iap.Argument;
|
|
|
|
import com.sun.mail.iap.ProtocolException;
|
|
|
|
import com.sun.mail.iap.Response;
|
2018-08-02 13:33:06 +00:00
|
|
|
import com.sun.mail.imap.IMAPFolder;
|
2020-01-07 16:43:27 +00:00
|
|
|
import com.sun.mail.imap.IMAPStore;
|
2020-12-02 13:39:48 +00:00
|
|
|
import com.sun.mail.imap.protocol.IMAPProtocol;
|
|
|
|
import com.sun.mail.imap.protocol.IMAPResponse;
|
2019-02-27 15:05:15 +00:00
|
|
|
|
2021-03-30 07:12:36 +00:00
|
|
|
import java.io.File;
|
|
|
|
import java.io.IOException;
|
2018-08-24 18:06:44 +00:00
|
|
|
import java.text.DateFormat;
|
2018-08-02 13:33:06 +00:00
|
|
|
import java.util.ArrayList;
|
2019-12-06 19:58:56 +00:00
|
|
|
import java.util.Arrays;
|
2018-08-02 13:33:06 +00:00
|
|
|
import java.util.Calendar;
|
2019-05-21 13:21:03 +00:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Comparator;
|
2018-08-02 13:33:06 +00:00
|
|
|
import java.util.Date;
|
2018-08-04 22:35:47 +00:00
|
|
|
import java.util.HashMap;
|
2019-12-06 19:58:56 +00:00
|
|
|
import java.util.Hashtable;
|
2020-11-17 17:29:02 +00:00
|
|
|
import java.util.LinkedHashMap;
|
2018-08-02 13:33:06 +00:00
|
|
|
import java.util.List;
|
2018-08-04 22:35:47 +00:00
|
|
|
import java.util.Map;
|
2019-12-08 08:00:00 +00:00
|
|
|
import java.util.Objects;
|
2018-08-02 13:33:06 +00:00
|
|
|
import java.util.concurrent.ExecutorService;
|
2020-09-23 06:19:28 +00:00
|
|
|
import java.util.concurrent.ThreadPoolExecutor;
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2019-06-23 18:56:07 +00:00
|
|
|
import javax.mail.AuthenticationFailedException;
|
2018-08-02 13:33:06 +00:00
|
|
|
import javax.mail.Folder;
|
2018-08-02 15:25:01 +00:00
|
|
|
import javax.mail.FolderClosedException;
|
2019-05-25 14:45:46 +00:00
|
|
|
import javax.mail.FolderNotFoundException;
|
2018-08-02 13:33:06 +00:00
|
|
|
import javax.mail.Message;
|
|
|
|
import javax.mail.MessagingException;
|
2018-08-15 19:34:22 +00:00
|
|
|
import javax.mail.NoSuchProviderException;
|
2020-01-07 16:43:27 +00:00
|
|
|
import javax.mail.Quota;
|
2019-04-29 19:54:49 +00:00
|
|
|
import javax.mail.ReadOnlyFolderException;
|
2020-12-02 11:00:35 +00:00
|
|
|
import javax.mail.Store;
|
2018-09-03 16:34:38 +00:00
|
|
|
import javax.mail.StoreClosedException;
|
2018-08-02 13:33:06 +00:00
|
|
|
import javax.mail.event.FolderAdapter;
|
|
|
|
import javax.mail.event.FolderEvent;
|
|
|
|
import javax.mail.event.MessageChangedEvent;
|
|
|
|
import javax.mail.event.MessageChangedListener;
|
|
|
|
import javax.mail.event.MessageCountAdapter;
|
|
|
|
import javax.mail.event.MessageCountEvent;
|
|
|
|
import javax.mail.event.StoreEvent;
|
|
|
|
import javax.mail.event.StoreListener;
|
2019-02-27 15:05:15 +00:00
|
|
|
|
2019-09-22 07:45:37 +00:00
|
|
|
import me.leolin.shortcutbadger.ShortcutBadger;
|
|
|
|
|
2019-12-06 19:58:56 +00:00
|
|
|
public class ServiceSynchronize extends ServiceBase implements SharedPreferences.OnSharedPreferenceChangeListener {
|
2020-09-24 09:14:27 +00:00
|
|
|
private Network lastActive = null;
|
2019-12-07 21:06:40 +00:00
|
|
|
private Boolean lastSuitable = null;
|
2019-12-12 08:19:30 +00:00
|
|
|
private long lastLost = 0;
|
2019-12-07 21:06:40 +00:00
|
|
|
private int lastAccounts = 0;
|
|
|
|
private int lastOperations = 0;
|
2020-10-28 10:44:15 +00:00
|
|
|
private ConnectionHelper.NetworkState lastNetworkState = null;
|
2019-02-28 07:55:08 +00:00
|
|
|
|
2020-07-25 17:54:28 +00:00
|
|
|
private boolean foreground = false;
|
2021-01-17 15:12:43 +00:00
|
|
|
private final Map<Long, Core.State> coreStates = new Hashtable<>();
|
|
|
|
private final MutableLiveData<ConnectionHelper.NetworkState> liveNetworkState = new MutableLiveData<>();
|
|
|
|
private final MutableLiveData<List<TupleAccountState>> liveAccountState = new MutableLiveData<>();
|
|
|
|
private final MediatorState liveAccountNetworkState = new MediatorState();
|
2019-12-12 07:51:48 +00:00
|
|
|
|
2021-01-17 15:12:43 +00:00
|
|
|
private static final ExecutorService executor = Helper.getBackgroundExecutor(1, "sync");
|
2020-12-31 11:29:58 +00:00
|
|
|
|
2021-01-02 20:11:31 +00:00
|
|
|
private static final long BACKUP_DELAY = 30 * 1000L; // milliseconds
|
2020-12-30 19:06:34 +00:00
|
|
|
private static final long PURGE_DELAY = 30 * 1000L; // milliseconds
|
2021-05-15 06:03:07 +00:00
|
|
|
private static final int QUIT_DELAY = 7; // seconds
|
2020-02-22 17:13:44 +00:00
|
|
|
private static final long STILL_THERE_THRESHOLD = 3 * 60 * 1000L; // milliseconds
|
2020-07-06 06:47:29 +00:00
|
|
|
private static final int OPTIMIZE_KEEP_ALIVE_INTERVAL = 12; // minutes
|
2020-07-06 05:47:20 +00:00
|
|
|
private static final int OPTIMIZE_POLL_INTERVAL = 15; // minutes
|
2021-03-17 11:47:00 +00:00
|
|
|
private static final int CONNECT_BACKOFF_START = 8; // seconds
|
|
|
|
private static final int CONNECT_BACKOFF_MAX = 8; // seconds (totally 8+2x20=48 seconds)
|
2021-08-07 07:03:55 +00:00
|
|
|
private static final int CONNECT_BACKOFF_INTERMEDIATE = 5; // minutes
|
2020-09-29 19:47:45 +00:00
|
|
|
private static final int CONNECT_BACKOFF_ALARM_START = 15; // minutes
|
|
|
|
private static final int CONNECT_BACKOFF_ALARM_MAX = 60; // minutes
|
2020-10-31 09:00:32 +00:00
|
|
|
private static final long CONNECT_BACKOFF_GRACE = 2 * 60 * 1000L; // milliseconds
|
2020-10-31 09:33:10 +00:00
|
|
|
private static final long LOST_RECENTLY = 150 * 1000L; // milliseconds
|
2021-01-20 21:20:49 +00:00
|
|
|
private static final int ACCOUNT_ERROR_AFTER = 90; // minutes
|
2020-10-01 13:46:20 +00:00
|
|
|
private static final int ACCOUNT_ERROR_AFTER_POLL = 4; // times
|
2020-11-01 08:09:51 +00:00
|
|
|
private static final int FAST_FAIL_THRESHOLD = 75; // percent
|
2021-08-06 06:21:06 +00:00
|
|
|
private static final int FAST_FAIL_COUNT = 3;
|
2020-11-10 19:06:02 +00:00
|
|
|
private static final int FETCH_YIELD_DURATION = 50; // milliseconds
|
2021-06-16 10:53:04 +00:00
|
|
|
private static final long WATCHDOG_INTERVAL = 60 * 60 * 1000L; // milliseconds
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2020-06-05 06:36:17 +00:00
|
|
|
private static final String ACTION_NEW_MESSAGE_COUNT = BuildConfig.APPLICATION_ID + ".NEW_MESSAGE_COUNT";
|
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
private static final List<String> PREF_EVAL = Collections.unmodifiableList(Arrays.asList(
|
2019-12-10 10:09:36 +00:00
|
|
|
"enabled", "poll_interval" // restart account(s)
|
2019-12-07 14:14:35 +00:00
|
|
|
));
|
|
|
|
|
|
|
|
private static final List<String> PREF_RELOAD = Collections.unmodifiableList(Arrays.asList(
|
2020-10-25 17:21:20 +00:00
|
|
|
"sync_nodate",
|
|
|
|
"sync_unseen",
|
|
|
|
"sync_flagged",
|
|
|
|
"delete_unseen",
|
|
|
|
"sync_kept",
|
|
|
|
"sync_folders",
|
|
|
|
"sync_shared_folders",
|
2021-04-26 08:12:29 +00:00
|
|
|
"download_headers", "download_eml",
|
2021-09-02 19:31:06 +00:00
|
|
|
"prefer_ip4", "bind_socket", "standalone_vpn", "tcp_keep_alive", "ssl_harden", // force reconnect
|
2020-12-02 13:39:48 +00:00
|
|
|
"experiments", "debug", "protocol", // force reconnect
|
2021-04-27 05:53:09 +00:00
|
|
|
"auth_plain", "auth_login", "auth_ntlm", "auth_sasl", // force reconnect
|
|
|
|
"exact_alarms" // force schedule
|
2019-12-07 14:14:35 +00:00
|
|
|
));
|
2019-02-27 15:05:15 +00:00
|
|
|
|
2019-02-28 07:55:08 +00:00
|
|
|
static final int PI_ALARM = 1;
|
2020-01-10 11:08:14 +00:00
|
|
|
static final int PI_BACKOFF = 2;
|
|
|
|
static final int PI_KEEPALIVE = 3;
|
2021-03-29 06:37:45 +00:00
|
|
|
static final int PI_ENABLE = 4;
|
2021-03-29 13:22:49 +00:00
|
|
|
static final int PI_POLL = 5;
|
2021-03-29 19:11:13 +00:00
|
|
|
static final int PI_WATCHDOG = 6;
|
2021-03-30 07:12:36 +00:00
|
|
|
static final int PI_UNSNOOZE = 7;
|
2021-05-10 12:52:39 +00:00
|
|
|
static final int PI_EXISTS = 8;
|
2018-09-20 09:10:19 +00:00
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
@Override
|
|
|
|
public void onCreate() {
|
2021-01-22 16:34:50 +00:00
|
|
|
EntityLog.log(this, "Service create" +
|
|
|
|
" version=" + BuildConfig.VERSION_NAME +
|
|
|
|
" process=" + android.os.Process.myPid());
|
2018-08-02 13:33:06 +00:00
|
|
|
super.onCreate();
|
2020-05-27 07:22:30 +00:00
|
|
|
|
2020-10-16 11:02:32 +00:00
|
|
|
if (isBackgroundService(this))
|
2020-05-27 07:22:30 +00:00
|
|
|
stopForeground(true);
|
|
|
|
else
|
2021-07-15 16:36:39 +00:00
|
|
|
startForeground(NotificationHelper.NOTIFICATION_SYNCHRONIZE,
|
|
|
|
getNotificationService(null, null).build());
|
2018-08-02 13:33:06 +00:00
|
|
|
|
|
|
|
// Listen for network changes
|
|
|
|
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
NetworkRequest.Builder builder = new NetworkRequest.Builder();
|
|
|
|
builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
|
2018-08-10 13:43:54 +00:00
|
|
|
// Removed because of Android VPN service
|
|
|
|
// builder.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
|
2019-10-04 15:17:42 +00:00
|
|
|
cm.registerNetworkCallback(builder.build(), networkCallback);
|
2019-07-11 06:42:20 +00:00
|
|
|
|
2019-10-04 15:17:42 +00:00
|
|
|
IntentFilter iif = new IntentFilter();
|
|
|
|
iif.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
|
|
|
|
iif.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
|
|
|
|
registerReceiver(connectionChangedReceiver, iif);
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2020-06-12 12:02:14 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
|
|
|
|
registerReceiver(idleModeChangedReceiver, new IntentFilter(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED));
|
|
|
|
|
2021-01-17 16:23:26 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
|
|
|
|
registerReceiver(dataSaverChanged, new IntentFilter(ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED));
|
|
|
|
|
2020-10-16 11:02:32 +00:00
|
|
|
final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
|
|
|
|
|
2018-08-24 18:06:44 +00:00
|
|
|
DB db = DB.getInstance(this);
|
2018-08-05 10:56:24 +00:00
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
db.account().liveAccountState().observe(this, new Observer<List<TupleAccountState>>() {
|
|
|
|
@Override
|
|
|
|
public void onChanged(List<TupleAccountState> accountStates) {
|
|
|
|
liveAccountState.postValue(accountStates);
|
|
|
|
}
|
|
|
|
});
|
2019-12-06 15:00:11 +00:00
|
|
|
|
|
|
|
liveAccountNetworkState.addSource(liveNetworkState, new Observer<ConnectionHelper.NetworkState>() {
|
|
|
|
@Override
|
|
|
|
public void onChanged(ConnectionHelper.NetworkState networkState) {
|
|
|
|
liveAccountNetworkState.post(networkState);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
liveAccountNetworkState.addSource(liveAccountState, new Observer<List<TupleAccountState>>() {
|
|
|
|
@Override
|
|
|
|
public void onChanged(List<TupleAccountState> accountStates) {
|
|
|
|
liveAccountNetworkState.post(accountStates);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2019-12-07 19:32:58 +00:00
|
|
|
liveAccountNetworkState.observeForever(new Observer<List<TupleAccountNetworkState>>() {
|
2020-01-15 11:07:45 +00:00
|
|
|
private boolean fts = false;
|
2020-08-24 12:33:32 +00:00
|
|
|
private int lastEventId = 0;
|
|
|
|
private int lastQuitId = -1;
|
2020-12-31 13:12:21 +00:00
|
|
|
private List<Long> initialized = new ArrayList<>();
|
2019-12-06 19:58:56 +00:00
|
|
|
private List<TupleAccountNetworkState> accountStates = new ArrayList<>();
|
2019-12-07 14:14:35 +00:00
|
|
|
private ExecutorService queue = Helper.getBackgroundExecutor(1, "service");
|
2019-12-06 19:58:56 +00:00
|
|
|
|
2019-12-06 15:00:11 +00:00
|
|
|
@Override
|
|
|
|
public void onChanged(List<TupleAccountNetworkState> accountNetworkStates) {
|
2019-12-07 19:32:58 +00:00
|
|
|
if (accountNetworkStates == null) {
|
2019-12-09 21:26:29 +00:00
|
|
|
// Destroy
|
2019-12-12 07:51:48 +00:00
|
|
|
for (TupleAccountNetworkState prev : accountStates)
|
2019-12-07 19:32:58 +00:00
|
|
|
stop(prev);
|
|
|
|
|
2020-01-12 18:28:19 +00:00
|
|
|
quit(null);
|
2019-12-07 19:32:58 +00:00
|
|
|
|
|
|
|
accountStates.clear();
|
2019-12-12 07:51:48 +00:00
|
|
|
coreStates.clear();
|
2019-12-07 19:32:58 +00:00
|
|
|
liveAccountNetworkState.removeObserver(this);
|
|
|
|
} else {
|
2019-12-07 21:06:40 +00:00
|
|
|
int accounts = 0;
|
|
|
|
int operations = 0;
|
2020-08-24 12:33:32 +00:00
|
|
|
boolean event = false;
|
2019-12-07 19:32:58 +00:00
|
|
|
boolean runService = false;
|
|
|
|
for (TupleAccountNetworkState current : accountNetworkStates) {
|
2019-12-18 16:43:28 +00:00
|
|
|
Log.d("### evaluating " + current);
|
2020-12-31 13:12:21 +00:00
|
|
|
if (!initialized.contains(current.accountState.id)) {
|
|
|
|
initialized.add(current.accountState.id);
|
|
|
|
init(current);
|
|
|
|
}
|
2019-12-07 19:32:58 +00:00
|
|
|
if (current.accountState.shouldRun(current.enabled))
|
|
|
|
runService = true;
|
2020-12-26 15:41:34 +00:00
|
|
|
if (!current.accountState.isTransient(ServiceSynchronize.this) &&
|
2020-11-01 08:40:42 +00:00
|
|
|
("connected".equals(current.accountState.state) || current.accountState.backoff_until != null))
|
2019-12-07 21:06:40 +00:00
|
|
|
accounts++;
|
2019-12-09 07:33:25 +00:00
|
|
|
if (current.accountState.synchronize)
|
|
|
|
operations += current.accountState.operations;
|
2019-12-07 19:32:58 +00:00
|
|
|
|
2019-12-10 10:09:36 +00:00
|
|
|
long account = current.command.getLong("account", -1);
|
|
|
|
if (account > 0 && !current.accountState.id.equals(account))
|
|
|
|
continue;
|
|
|
|
|
2021-02-25 09:19:15 +00:00
|
|
|
boolean sync = current.command.getBoolean("sync", false);
|
|
|
|
boolean force = current.command.getBoolean("force", false);
|
2021-07-17 09:53:14 +00:00
|
|
|
if (force) {
|
2021-03-16 07:54:59 +00:00
|
|
|
sync = true;
|
2021-07-17 09:53:14 +00:00
|
|
|
current.accountState.operations++;
|
|
|
|
}
|
2021-02-25 09:19:15 +00:00
|
|
|
|
2019-12-07 19:32:58 +00:00
|
|
|
int index = accountStates.indexOf(current);
|
|
|
|
if (index < 0) {
|
2021-07-17 09:53:14 +00:00
|
|
|
if (current.canRun()) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### new " + current +
|
|
|
|
" force=" + force +
|
|
|
|
" start=" + current.canRun() +
|
|
|
|
" sync=" + current.accountState.isEnabled(current.enabled) +
|
|
|
|
" enabled=" + current.accountState.synchronize +
|
|
|
|
" ondemand=" + current.accountState.ondemand +
|
|
|
|
" folders=" + current.accountState.folders +
|
|
|
|
" ops=" + current.accountState.operations +
|
|
|
|
" tbd=" + current.accountState.tbd +
|
|
|
|
" state=" + current.accountState.state +
|
|
|
|
" active=" + current.networkState.getActive());
|
2020-08-24 12:33:32 +00:00
|
|
|
event = true;
|
2021-02-25 09:19:15 +00:00
|
|
|
start(current, current.accountState.isEnabled(current.enabled) || sync, force);
|
2019-12-07 19:32:58 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-12-09 21:26:29 +00:00
|
|
|
boolean reload = false;
|
2019-12-10 10:09:36 +00:00
|
|
|
switch (current.command.getString("name")) {
|
|
|
|
case "reload":
|
|
|
|
reload = true;
|
|
|
|
break;
|
|
|
|
}
|
2019-12-09 21:26:29 +00:00
|
|
|
|
2021-01-16 10:28:08 +00:00
|
|
|
TupleAccountNetworkState prev = accountStates.get(index);
|
|
|
|
Core.State state = coreStates.get(current.accountState.id);
|
|
|
|
if (state != null)
|
|
|
|
state.setNetworkState(current.networkState);
|
|
|
|
|
2019-12-10 09:36:59 +00:00
|
|
|
accountStates.remove(index);
|
|
|
|
|
2019-12-08 08:00:00 +00:00
|
|
|
// Some networks disallow email server connections:
|
|
|
|
// - reload on network type change when disconnected
|
2020-01-10 11:08:14 +00:00
|
|
|
if (reload ||
|
2021-07-17 09:53:14 +00:00
|
|
|
prev.canRun() != current.canRun() ||
|
2020-10-27 19:49:20 +00:00
|
|
|
!prev.accountState.equals(current.accountState)) {
|
2021-07-17 09:53:14 +00:00
|
|
|
if (prev.canRun() || current.canRun())
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### changed " + current +
|
|
|
|
" reload=" + reload +
|
|
|
|
" force=" + force +
|
|
|
|
" stop=" + prev.canRun() +
|
|
|
|
" start=" + current.canRun() +
|
|
|
|
" sync=" + sync +
|
|
|
|
" enabled=" + current.accountState.isEnabled(current.enabled) +
|
|
|
|
" should=" + current.accountState.shouldRun(current.enabled) +
|
|
|
|
" changed=" + !prev.accountState.equals(current.accountState) +
|
|
|
|
" synchronize=" + current.accountState.synchronize +
|
|
|
|
" ondemand=" + current.accountState.ondemand +
|
|
|
|
" folders=" + current.accountState.folders +
|
|
|
|
" ops=" + current.accountState.operations +
|
|
|
|
" tbd=" + current.accountState.tbd +
|
|
|
|
" state=" + current.accountState.state +
|
|
|
|
" active=" + prev.networkState.getActive() + "/" + current.networkState.getActive());
|
2021-07-17 09:53:14 +00:00
|
|
|
if (prev.canRun()) {
|
2020-08-24 12:33:32 +00:00
|
|
|
event = true;
|
2020-01-10 11:08:14 +00:00
|
|
|
stop(prev);
|
2020-08-24 12:33:32 +00:00
|
|
|
}
|
2021-07-17 09:53:14 +00:00
|
|
|
if (current.canRun()) {
|
2020-08-24 12:33:32 +00:00
|
|
|
event = true;
|
2020-07-12 06:44:50 +00:00
|
|
|
start(current, current.accountState.isEnabled(current.enabled) || sync, force);
|
2020-08-24 12:33:32 +00:00
|
|
|
}
|
2020-10-27 19:49:20 +00:00
|
|
|
} else {
|
|
|
|
if (state != null) {
|
|
|
|
Network p = prev.networkState.getActive();
|
|
|
|
if (p != null && !p.equals(current.networkState.getActive())) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### changed " + current +
|
|
|
|
" active=" + prev.networkState.getActive() + "/" + current.networkState.getActive());
|
2020-10-27 19:49:20 +00:00
|
|
|
state.error(new OperationCanceledException("Active network changed"));
|
|
|
|
}
|
|
|
|
}
|
2019-12-07 19:32:58 +00:00
|
|
|
}
|
2019-12-06 19:58:56 +00:00
|
|
|
}
|
|
|
|
|
2019-12-07 19:32:58 +00:00
|
|
|
if (current.accountState.tbd == null)
|
|
|
|
accountStates.add(current);
|
2020-08-24 12:33:32 +00:00
|
|
|
else {
|
|
|
|
event = true;
|
2019-12-18 16:43:28 +00:00
|
|
|
delete(current);
|
2020-08-24 12:33:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (event) {
|
|
|
|
lastEventId++;
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### eventId=" + lastEventId);
|
2019-12-07 19:32:58 +00:00
|
|
|
}
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2020-01-17 07:54:16 +00:00
|
|
|
if (lastAccounts != accounts || lastOperations != operations) {
|
|
|
|
lastAccounts = accounts;
|
|
|
|
lastOperations = operations;
|
|
|
|
if (operations == 0) {
|
|
|
|
fts = true;
|
|
|
|
WorkerFts.init(ServiceSynchronize.this, false);
|
|
|
|
} else if (fts) {
|
|
|
|
fts = false;
|
|
|
|
WorkerFts.cancel(ServiceSynchronize.this);
|
2019-12-07 19:32:58 +00:00
|
|
|
}
|
2020-02-22 21:09:46 +00:00
|
|
|
|
2021-01-02 20:11:31 +00:00
|
|
|
getMainHandler().removeCallbacks(backup);
|
|
|
|
getMainHandler().postDelayed(backup, BACKUP_DELAY);
|
|
|
|
|
2020-10-28 10:44:15 +00:00
|
|
|
if (!isBackgroundService(ServiceSynchronize.this))
|
2020-05-27 07:22:30 +00:00
|
|
|
try {
|
2021-07-15 16:36:39 +00:00
|
|
|
NotificationManager nm =
|
|
|
|
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
|
|
nm.notify(NotificationHelper.NOTIFICATION_SYNCHRONIZE,
|
|
|
|
getNotificationService(lastAccounts, lastOperations).build());
|
2020-05-27 07:22:30 +00:00
|
|
|
} catch (Throwable ex) {
|
2020-02-22 21:09:46 +00:00
|
|
|
/*
|
|
|
|
java.lang.NullPointerException: Attempt to invoke interface method 'java.util.Iterator java.lang.Iterable.iterator()' on a null object reference
|
|
|
|
at android.app.ApplicationPackageManager.getUserIfProfile(ApplicationPackageManager.java:2167)
|
|
|
|
at android.app.ApplicationPackageManager.getUserBadgeForDensity(ApplicationPackageManager.java:1002)
|
|
|
|
at android.app.Notification$Builder.getProfileBadgeDrawable(Notification.java:2890)
|
|
|
|
at android.app.Notification$Builder.hasThreeLines(Notification.java:3105)
|
|
|
|
at android.app.Notification$Builder.build(Notification.java:3659)
|
|
|
|
at androidx.core.app.NotificationCompatBuilder.buildInternal(SourceFile:355)
|
|
|
|
at androidx.core.app.NotificationCompatBuilder.build(SourceFile:247)
|
|
|
|
at androidx.core.app.NotificationCompat$Builder.build(SourceFile:1677)
|
|
|
|
*/
|
2020-05-27 07:22:30 +00:00
|
|
|
Log.w(ex);
|
|
|
|
}
|
2020-01-17 07:54:16 +00:00
|
|
|
}
|
|
|
|
|
2020-08-24 12:33:32 +00:00
|
|
|
if (!runService && lastQuitId != lastEventId) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### quitting" +
|
|
|
|
" run=" + runService +
|
|
|
|
" startId=" + lastQuitId + "/" + lastEventId);
|
2020-08-24 12:33:32 +00:00
|
|
|
lastQuitId = lastEventId;
|
|
|
|
quit(lastEventId);
|
|
|
|
}
|
2019-12-06 19:58:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-31 13:12:21 +00:00
|
|
|
private void init(final TupleAccountNetworkState accountNetworkState) {
|
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### init " + accountNetworkState);
|
2020-12-31 13:12:21 +00:00
|
|
|
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
db.account().setAccountState(accountNetworkState.accountState.id, null);
|
|
|
|
db.account().setAccountBackoff(accountNetworkState.accountState.id, null);
|
|
|
|
|
|
|
|
for (EntityFolder folder : db.folder().getFolders(accountNetworkState.accountState.id, false, false)) {
|
|
|
|
db.folder().setFolderState(folder.id, null);
|
|
|
|
db.folder().setFolderSyncState(folder.id, null);
|
|
|
|
db.folder().setFolderPollCount(folder.id, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
db.operation().resetOperationStates(accountNetworkState.accountState.id);
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-07-12 06:44:50 +00:00
|
|
|
private void start(final TupleAccountNetworkState accountNetworkState, boolean sync, boolean force) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2020-07-12 06:44:50 +00:00
|
|
|
"Service start=" + accountNetworkState + " sync=" + sync + " force=" + force);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2019-12-07 21:06:40 +00:00
|
|
|
final Core.State astate = new Core.State(accountNetworkState.networkState);
|
2019-12-07 14:14:35 +00:00
|
|
|
astate.runnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
2020-07-12 06:44:50 +00:00
|
|
|
monitorAccount(accountNetworkState.accountState, astate, sync, force);
|
2019-12-07 14:14:35 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(accountNetworkState.accountState.name, ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, "sync.account." + accountNetworkState.accountState.id);
|
2019-12-12 07:51:48 +00:00
|
|
|
coreStates.put(accountNetworkState.accountState.id, astate);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2019-12-06 19:58:56 +00:00
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-10-30 07:02:00 +00:00
|
|
|
try {
|
|
|
|
Map<String, String> crumb = new HashMap<>();
|
|
|
|
crumb.put("account", accountNetworkState.accountState.id.toString());
|
|
|
|
crumb.put("connected", Boolean.toString(accountNetworkState.networkState.isConnected()));
|
|
|
|
crumb.put("suitable", Boolean.toString(accountNetworkState.networkState.isSuitable()));
|
|
|
|
crumb.put("unmetered", Boolean.toString(accountNetworkState.networkState.isUnmetered()));
|
|
|
|
crumb.put("roaming", Boolean.toString(accountNetworkState.networkState.isRoaming()));
|
|
|
|
crumb.put("lastLost", new Date(lastLost).toString());
|
|
|
|
Log.breadcrumb("start", crumb);
|
|
|
|
|
|
|
|
Log.i("### start=" + accountNetworkState + " sync=" + sync);
|
|
|
|
astate.start();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### started=" + accountNetworkState);
|
2020-10-30 07:02:00 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-12-06 19:58:56 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
private void stop(final TupleAccountNetworkState accountNetworkState) {
|
2019-12-12 07:51:48 +00:00
|
|
|
final Core.State state = coreStates.get(accountNetworkState.accountState.id);
|
2020-10-30 07:02:00 +00:00
|
|
|
if (state == null)
|
|
|
|
return;
|
2019-12-12 07:51:48 +00:00
|
|
|
coreStates.remove(accountNetworkState.accountState.id);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"Service stop=" + accountNetworkState);
|
2020-10-30 07:02:00 +00:00
|
|
|
|
2019-12-06 19:58:56 +00:00
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-10-30 07:02:00 +00:00
|
|
|
try {
|
|
|
|
Map<String, String> crumb = new HashMap<>();
|
|
|
|
crumb.put("account", accountNetworkState.accountState.id.toString());
|
|
|
|
crumb.put("connected", Boolean.toString(accountNetworkState.networkState.isConnected()));
|
|
|
|
crumb.put("suitable", Boolean.toString(accountNetworkState.networkState.isSuitable()));
|
|
|
|
crumb.put("unmetered", Boolean.toString(accountNetworkState.networkState.isUnmetered()));
|
|
|
|
crumb.put("roaming", Boolean.toString(accountNetworkState.networkState.isRoaming()));
|
|
|
|
crumb.put("lastLost", new Date(lastLost).toString());
|
|
|
|
Log.breadcrumb("stop", crumb);
|
|
|
|
|
|
|
|
Log.i("### stop=" + accountNetworkState);
|
2021-04-05 06:23:00 +00:00
|
|
|
db.account().setAccountThread(accountNetworkState.accountState.id, null);
|
2020-10-30 07:02:00 +00:00
|
|
|
state.stop();
|
|
|
|
state.join();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### stopped=" + accountNetworkState);
|
2020-10-30 07:02:00 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-12-06 19:58:56 +00:00
|
|
|
}
|
|
|
|
});
|
2019-12-06 15:00:11 +00:00
|
|
|
}
|
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
private void delete(final TupleAccountNetworkState accountNetworkState) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"Service delete=" + accountNetworkState);
|
2019-06-01 06:44:46 +00:00
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-10-30 07:02:00 +00:00
|
|
|
try {
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
db.account().deleteAccount(accountNetworkState.accountState.id);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2020-10-30 07:02:00 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
|
|
NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
|
|
nm.deleteNotificationChannel(EntityAccount.getNotificationChannelId(accountNetworkState.accountState.id));
|
|
|
|
}
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2019-12-07 14:14:35 +00:00
|
|
|
}
|
2019-06-01 13:58:09 +00:00
|
|
|
}
|
2019-12-07 14:14:35 +00:00
|
|
|
});
|
|
|
|
}
|
2019-06-01 06:44:46 +00:00
|
|
|
|
2020-08-24 12:33:32 +00:00
|
|
|
private void quit(final Integer eventId) {
|
2019-12-07 14:14:35 +00:00
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-10-30 07:02:00 +00:00
|
|
|
try {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### quit eventId=" + eventId);
|
2020-10-30 07:02:00 +00:00
|
|
|
|
|
|
|
if (eventId == null) {
|
|
|
|
// Service destroy
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
List<EntityOperation> ops = db.operation().getOperations(EntityOperation.SYNC);
|
|
|
|
for (EntityOperation op : ops)
|
|
|
|
db.folder().setFolderSyncState(op.folder, null);
|
2021-01-02 19:59:18 +00:00
|
|
|
|
2021-01-02 22:02:04 +00:00
|
|
|
getMainHandler().removeCallbacks(backup);
|
2021-01-02 19:59:18 +00:00
|
|
|
MessageClassifier.save(ServiceSynchronize.this);
|
2020-10-30 07:02:00 +00:00
|
|
|
} else {
|
|
|
|
// Yield update notifications/widgets
|
2021-03-29 13:24:22 +00:00
|
|
|
for (int i = 0; i < QUIT_DELAY; i++) {
|
|
|
|
try {
|
|
|
|
Thread.sleep(1000L);
|
|
|
|
} catch (InterruptedException ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
}
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2021-03-29 13:24:22 +00:00
|
|
|
if (!eventId.equals(lastEventId)) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### quit cancelled eventId=" + eventId + "/" + lastEventId);
|
2021-03-29 13:24:22 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-10-30 07:02:00 +00:00
|
|
|
}
|
2020-08-24 12:33:32 +00:00
|
|
|
|
2020-10-30 07:02:00 +00:00
|
|
|
// Stop service
|
|
|
|
stopSelf();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### stop self eventId=" + eventId);
|
2020-10-17 13:57:01 +00:00
|
|
|
|
2020-10-30 07:02:00 +00:00
|
|
|
WorkerCleanup.cleanupConditionally(ServiceSynchronize.this);
|
|
|
|
}
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2020-01-12 18:28:19 +00:00
|
|
|
}
|
2019-12-07 14:14:35 +00:00
|
|
|
}
|
|
|
|
});
|
2018-08-24 18:06:44 +00:00
|
|
|
}
|
2021-01-02 20:11:31 +00:00
|
|
|
|
2021-03-30 16:44:45 +00:00
|
|
|
private final Runnable backup = new Runnable() {
|
2021-01-02 20:11:31 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
queue.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
MessageClassifier.save(ServiceSynchronize.this);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
2018-08-24 18:06:44 +00:00
|
|
|
});
|
|
|
|
|
2020-01-12 10:09:11 +00:00
|
|
|
final TwoStateOwner cowner = new TwoStateOwner(this, "liveUnseenNotify");
|
|
|
|
|
2021-09-02 21:06:59 +00:00
|
|
|
db.folder().liveSynchronizing().observe(this, new Observer<List<TupleFolderSync>>() {
|
2021-09-03 05:55:29 +00:00
|
|
|
private List<Long> lastAccounts = new ArrayList<>();
|
|
|
|
private List<Long> lastFolders = new ArrayList<>();
|
|
|
|
|
2020-01-12 10:09:11 +00:00
|
|
|
@Override
|
2021-09-02 21:06:59 +00:00
|
|
|
public void onChanged(List<TupleFolderSync> syncs) {
|
|
|
|
int syncing = 0;
|
2021-09-03 05:55:29 +00:00
|
|
|
boolean changed = false;
|
2021-09-02 21:06:59 +00:00
|
|
|
List<Long> accounts = new ArrayList<>();
|
|
|
|
List<Long> folders = new ArrayList<>();
|
|
|
|
if (syncs != null)
|
|
|
|
for (TupleFolderSync sync : syncs) {
|
|
|
|
if ("syncing".equals(sync.sync_state))
|
|
|
|
syncing++;
|
2021-09-03 05:55:29 +00:00
|
|
|
|
|
|
|
if (sync.unified && !accounts.contains(sync.account)) {
|
2021-09-02 21:06:59 +00:00
|
|
|
accounts.add(sync.account);
|
2021-09-03 05:55:29 +00:00
|
|
|
if (lastAccounts.contains(sync.account))
|
|
|
|
lastAccounts.remove(sync.account); // same
|
|
|
|
else
|
|
|
|
changed = true; // new
|
|
|
|
}
|
|
|
|
|
2021-09-02 21:06:59 +00:00
|
|
|
folders.add(sync.folder);
|
2021-09-03 05:55:29 +00:00
|
|
|
if (lastFolders.contains(sync.folder))
|
|
|
|
lastFolders.remove(sync.folder); // same
|
|
|
|
else
|
|
|
|
changed = true; // new
|
2021-09-02 21:06:59 +00:00
|
|
|
}
|
|
|
|
|
2021-09-03 05:55:29 +00:00
|
|
|
changed = (changed || lastAccounts.size() > 0 || lastFolders.size() > 0); // deleted
|
|
|
|
lastAccounts = accounts;
|
|
|
|
lastFolders = folders;
|
|
|
|
|
|
|
|
Log.i("Changed=" + changed +
|
|
|
|
" syncing=" + syncing +
|
2021-09-02 21:06:59 +00:00
|
|
|
" folders=" + folders.size() +
|
|
|
|
" accounts=" + accounts.size());
|
|
|
|
|
|
|
|
if (syncing == 0)
|
2020-01-12 10:09:11 +00:00
|
|
|
cowner.start();
|
|
|
|
else
|
|
|
|
cowner.stop();
|
2021-09-02 21:06:59 +00:00
|
|
|
|
2021-09-03 05:55:29 +00:00
|
|
|
if (!changed)
|
|
|
|
return;
|
|
|
|
|
2021-09-02 21:06:59 +00:00
|
|
|
for (String _key : prefs.getAll().keySet())
|
|
|
|
if (_key.startsWith("widget.") && _key.endsWith(".refresh") &&
|
|
|
|
prefs.getBoolean(_key, false)) {
|
|
|
|
int appWidgetId = Integer.parseInt(_key.split("\\.")[1]);
|
|
|
|
|
|
|
|
String key = "widget." + appWidgetId + ".sync";
|
|
|
|
boolean sync = prefs.contains(key);
|
|
|
|
if (!sync)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
long account = prefs.getLong("widget." + appWidgetId + ".account", -1L);
|
|
|
|
long folder = prefs.getLong("widget." + appWidgetId + ".folder", -1L);
|
|
|
|
|
|
|
|
if (folder > 0) {
|
|
|
|
if (!folders.contains(folder)) {
|
|
|
|
prefs.edit().remove(key).apply();
|
|
|
|
WidgetUnified.init(ServiceSynchronize.this, appWidgetId);
|
|
|
|
}
|
|
|
|
} else if (account > 0) {
|
|
|
|
if (!accounts.contains(account)) {
|
|
|
|
prefs.edit().remove(key).apply();
|
|
|
|
WidgetUnified.init(ServiceSynchronize.this, appWidgetId);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (accounts.size() == 0) {
|
|
|
|
prefs.edit().remove(key).apply();
|
|
|
|
WidgetUnified.init(ServiceSynchronize.this, appWidgetId);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-01-12 10:09:11 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-02-15 09:47:03 +00:00
|
|
|
Core.NotificationData notificationData = new Core.NotificationData(this);
|
2019-08-24 07:06:57 +00:00
|
|
|
|
2019-03-20 14:52:51 +00:00
|
|
|
db.message().liveUnseenNotify().observe(cowner, new Observer<List<TupleMessageEx>>() {
|
2021-03-30 16:44:45 +00:00
|
|
|
private final ExecutorService executor =
|
2019-10-10 11:26:44 +00:00
|
|
|
Helper.getBackgroundExecutor(1, "notify");
|
2019-08-01 07:19:22 +00:00
|
|
|
|
2018-08-24 18:06:44 +00:00
|
|
|
@Override
|
2019-08-01 07:19:22 +00:00
|
|
|
public void onChanged(final List<TupleMessageEx> messages) {
|
|
|
|
executor.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
2021-02-15 09:47:03 +00:00
|
|
|
Core.notifyMessages(ServiceSynchronize.this, messages, notificationData, foreground);
|
2019-08-01 07:19:22 +00:00
|
|
|
} catch (SecurityException ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ServiceSynchronize.this);
|
|
|
|
prefs.edit().remove("sound").apply();
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
2020-03-28 09:02:00 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
db.message().liveWidgetUnseen(null).observe(cowner, new Observer<List<TupleMessageStats>>() {
|
2020-04-25 06:51:50 +00:00
|
|
|
private Integer lastCount = null;
|
2020-03-28 09:02:00 +00:00
|
|
|
private List<TupleMessageStats> last = null;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onChanged(List<TupleMessageStats> stats) {
|
|
|
|
if (stats == null)
|
|
|
|
stats = new ArrayList<>();
|
|
|
|
|
|
|
|
boolean changed = false;
|
|
|
|
if (last == null || last.size() != stats.size())
|
|
|
|
changed = true;
|
|
|
|
else
|
|
|
|
for (int i = 0; i < stats.size(); i++)
|
|
|
|
if (!last.get(i).equals(stats.get(i))) {
|
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!changed)
|
|
|
|
return;
|
|
|
|
|
2020-04-20 08:38:45 +00:00
|
|
|
last = stats;
|
|
|
|
|
2021-05-16 08:17:52 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, "Widget update");
|
2020-06-16 09:33:28 +00:00
|
|
|
Widget.update(ServiceSynchronize.this);
|
2020-03-28 09:02:00 +00:00
|
|
|
|
|
|
|
boolean badge = prefs.getBoolean("badge", true);
|
|
|
|
boolean unseen_ignored = prefs.getBoolean("unseen_ignored", false);
|
|
|
|
|
|
|
|
int count = 0;
|
|
|
|
for (TupleMessageStats stat : stats) {
|
|
|
|
Integer unseen = (unseen_ignored ? stat.notifying : stat.unseen);
|
|
|
|
if (unseen != null)
|
|
|
|
count += unseen;
|
|
|
|
}
|
|
|
|
|
2020-04-25 06:51:50 +00:00
|
|
|
if (lastCount == null || !lastCount.equals(count)) {
|
|
|
|
lastCount = count;
|
2021-09-01 13:08:59 +00:00
|
|
|
|
|
|
|
EntityLog.log(ServiceSynchronize.this, " Badge count=" + count +
|
|
|
|
"enabled=" + badge + " Unseen/ignored=" + unseen_ignored);
|
|
|
|
|
2020-06-05 06:36:17 +00:00
|
|
|
// Broadcast new message count
|
|
|
|
try {
|
|
|
|
Intent intent = new Intent(ACTION_NEW_MESSAGE_COUNT);
|
|
|
|
intent.putExtra("count", count);
|
|
|
|
sendBroadcast(intent);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update badge
|
2020-04-25 06:51:50 +00:00
|
|
|
try {
|
|
|
|
if (count == 0 || !badge)
|
|
|
|
ShortcutBadger.removeCount(ServiceSynchronize.this);
|
|
|
|
else
|
|
|
|
ShortcutBadger.applyCount(ServiceSynchronize.this, count);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2020-03-28 09:02:00 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
});
|
2019-02-27 20:49:49 +00:00
|
|
|
|
2019-12-01 10:42:54 +00:00
|
|
|
db.message().liveWidgetUnified().observe(cowner, new Observer<List<TupleMessageWidgetCount>>() {
|
2019-11-24 11:33:50 +00:00
|
|
|
private List<TupleMessageWidgetCount> last = null;
|
2019-07-25 15:22:00 +00:00
|
|
|
|
|
|
|
@Override
|
2019-11-24 11:33:50 +00:00
|
|
|
public void onChanged(List<TupleMessageWidgetCount> current) {
|
|
|
|
if (current == null)
|
|
|
|
current = new ArrayList<>();
|
|
|
|
|
|
|
|
boolean changed = false;
|
|
|
|
if (last == null || last.size() != current.size())
|
|
|
|
changed = true;
|
|
|
|
else
|
|
|
|
for (int i = 0; i < current.size(); i++)
|
|
|
|
if (!current.get(i).equals(last.get(i))) {
|
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-06-16 09:33:28 +00:00
|
|
|
if (changed)
|
|
|
|
WidgetUnified.updateData(ServiceSynchronize.this);
|
2019-11-18 09:14:37 +00:00
|
|
|
|
|
|
|
last = current;
|
2019-07-25 15:22:00 +00:00
|
|
|
}
|
|
|
|
});
|
2019-12-06 19:58:56 +00:00
|
|
|
|
|
|
|
prefs.registerOnSharedPreferenceChangeListener(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
|
2020-10-28 10:44:15 +00:00
|
|
|
if (PREF_EVAL.contains(key)) {
|
2019-12-09 21:26:29 +00:00
|
|
|
Bundle command = new Bundle();
|
2020-04-07 09:20:27 +00:00
|
|
|
command.putString("pref", key);
|
2019-12-09 21:26:29 +00:00
|
|
|
command.putString("name", "eval");
|
2019-12-12 10:57:35 +00:00
|
|
|
liveAccountNetworkState.post(command);
|
2020-10-28 10:44:15 +00:00
|
|
|
} else if (PREF_RELOAD.contains(key) || ConnectionHelper.PREF_NETWORK.contains(key)) {
|
2020-10-29 12:57:42 +00:00
|
|
|
if (ConnectionHelper.PREF_NETWORK.contains(key))
|
2021-01-16 18:21:31 +00:00
|
|
|
updateNetworkState(null, "preference");
|
2019-12-09 21:26:29 +00:00
|
|
|
Bundle command = new Bundle();
|
2020-04-07 09:20:27 +00:00
|
|
|
command.putString("pref", key);
|
2019-12-09 21:26:29 +00:00
|
|
|
command.putString("name", "reload");
|
|
|
|
liveAccountNetworkState.post(command);
|
|
|
|
}
|
2018-10-16 10:26:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onDestroy() {
|
2019-03-25 14:05:52 +00:00
|
|
|
EntityLog.log(this, "Service destroy");
|
2018-10-16 10:26:35 +00:00
|
|
|
|
2019-12-06 19:58:56 +00:00
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
|
|
|
|
prefs.unregisterOnSharedPreferenceChangeListener(this);
|
|
|
|
|
2021-01-17 16:23:26 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
|
|
|
|
unregisterReceiver(dataSaverChanged);
|
|
|
|
|
2020-06-12 12:02:14 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
|
|
|
|
unregisterReceiver(idleModeChangedReceiver);
|
|
|
|
|
2019-10-04 15:17:42 +00:00
|
|
|
unregisterReceiver(connectionChangedReceiver);
|
2019-07-11 06:42:20 +00:00
|
|
|
|
2018-10-16 10:26:35 +00:00
|
|
|
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
|
2019-10-04 15:17:42 +00:00
|
|
|
cm.unregisterNetworkCallback(networkCallback);
|
2018-10-16 10:26:35 +00:00
|
|
|
|
2019-12-07 19:32:58 +00:00
|
|
|
liveAccountNetworkState.postDestroy();
|
2018-10-21 18:29:28 +00:00
|
|
|
|
2020-07-03 19:00:15 +00:00
|
|
|
TTSHelper.shutdown();
|
|
|
|
|
2019-08-12 06:18:28 +00:00
|
|
|
try {
|
|
|
|
stopForeground(true);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
/*
|
|
|
|
OnePlus A6013 - Android 9
|
|
|
|
|
|
|
|
java.lang.RuntimeException: Unable to stop service eu.faircode.email.ServiceSynchronize@3995fc9: java.lang.NullPointerException: Attempt to invoke virtual method 'long java.lang.Long.longValue()' on a null object reference
|
|
|
|
at android.app.ActivityThread.handleStopService(ActivityThread.java:3908)
|
|
|
|
at android.app.ActivityThread.access$1900(ActivityThread.java:209)
|
|
|
|
at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1826)
|
|
|
|
at android.os.Handler.dispatchMessage(Handler.java:106)
|
|
|
|
at android.os.Looper.loop(Looper.java:193)
|
|
|
|
at android.app.ActivityThread.main(ActivityThread.java:6954)
|
|
|
|
at java.lang.reflect.Method.invoke(Method.java:-2)
|
|
|
|
at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:537)
|
|
|
|
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:858)
|
|
|
|
Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'long java.lang.Long.longValue()' on a null object reference
|
|
|
|
at android.os.Parcel.createException(Parcel.java:1956)
|
|
|
|
at android.os.Parcel.readException(Parcel.java:1918)
|
|
|
|
at android.os.Parcel.readException(Parcel.java:1868)
|
|
|
|
at android.app.IActivityManager$Stub$Proxy.setServiceForeground(IActivityManager.java:5111)
|
|
|
|
at android.app.Service.stopForeground(Service.java:724)
|
|
|
|
at android.app.Service.stopForeground(Service.java:710)
|
|
|
|
*/
|
|
|
|
}
|
2018-10-16 10:26:35 +00:00
|
|
|
|
2021-07-15 16:36:39 +00:00
|
|
|
NotificationManager nm =
|
|
|
|
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
|
|
nm.cancel(NotificationHelper.NOTIFICATION_SYNCHRONIZE);
|
2018-10-16 10:26:35 +00:00
|
|
|
|
|
|
|
super.onDestroy();
|
|
|
|
}
|
|
|
|
|
2020-01-13 16:16:02 +00:00
|
|
|
@Override
|
|
|
|
public void onTaskRemoved(Intent rootIntent) {
|
|
|
|
super.onTaskRemoved(rootIntent);
|
|
|
|
Log.i("Task removed=" + rootIntent);
|
|
|
|
}
|
|
|
|
|
2018-10-16 10:26:35 +00:00
|
|
|
@Override
|
|
|
|
public int onStartCommand(Intent intent, int flags, int startId) {
|
|
|
|
String action = (intent == null ? null : intent.getAction());
|
2019-12-07 16:02:42 +00:00
|
|
|
String reason = (intent == null ? null : intent.getStringExtra("reason"));
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### Service command " + intent +
|
|
|
|
" action=" + action + " reason=" + reason);
|
2019-02-14 12:28:03 +00:00
|
|
|
Log.logExtras(intent);
|
2018-10-16 10:26:35 +00:00
|
|
|
|
|
|
|
super.onStartCommand(intent, flags, startId);
|
2020-05-27 07:22:30 +00:00
|
|
|
|
2020-10-16 11:02:32 +00:00
|
|
|
if (isBackgroundService(this))
|
2020-05-27 07:22:30 +00:00
|
|
|
stopForeground(true);
|
|
|
|
else
|
2021-07-15 16:36:39 +00:00
|
|
|
startForeground(NotificationHelper.NOTIFICATION_SYNCHRONIZE,
|
|
|
|
getNotificationService(null, null).build());
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-12-28 17:21:31 +00:00
|
|
|
if (action != null)
|
|
|
|
try {
|
2019-12-12 07:51:48 +00:00
|
|
|
switch (action.split(":")[0]) {
|
2021-03-29 06:37:45 +00:00
|
|
|
case "enable":
|
|
|
|
onEnable(intent);
|
|
|
|
break;
|
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
case "eval":
|
2019-12-12 07:51:48 +00:00
|
|
|
onEval(intent);
|
2019-02-14 12:28:03 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-09 21:26:29 +00:00
|
|
|
case "reload":
|
2019-12-12 07:51:48 +00:00
|
|
|
onReload(intent);
|
2019-12-09 21:26:29 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-12 10:10:57 +00:00
|
|
|
case "backoff":
|
|
|
|
case "keepalive":
|
2019-12-12 07:51:48 +00:00
|
|
|
onWakeup(intent);
|
2018-12-28 17:21:31 +00:00
|
|
|
break;
|
|
|
|
|
2021-03-30 07:12:36 +00:00
|
|
|
case "unsnooze":
|
|
|
|
onUnsnooze(intent);
|
|
|
|
break;
|
|
|
|
|
2021-05-10 12:52:39 +00:00
|
|
|
case "exists":
|
|
|
|
onExists(intent);
|
|
|
|
break;
|
|
|
|
|
2020-07-25 17:54:28 +00:00
|
|
|
case "state":
|
|
|
|
onState(intent);
|
|
|
|
break;
|
|
|
|
|
2021-03-29 13:22:49 +00:00
|
|
|
case "poll":
|
|
|
|
onPoll(intent);
|
|
|
|
break;
|
|
|
|
|
2019-12-09 21:26:29 +00:00
|
|
|
case "alarm":
|
2019-12-12 07:51:48 +00:00
|
|
|
onAlarm(intent);
|
2019-05-12 18:15:16 +00:00
|
|
|
break;
|
|
|
|
|
2020-03-25 09:44:50 +00:00
|
|
|
case "watchdog":
|
|
|
|
onWatchdog(intent);
|
|
|
|
break;
|
|
|
|
|
2018-12-28 17:21:31 +00:00
|
|
|
default:
|
|
|
|
Log.w("Unknown action: " + action);
|
|
|
|
}
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2018-08-22 12:30:27 +00:00
|
|
|
}
|
2018-08-07 20:03:45 +00:00
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
return START_STICKY;
|
|
|
|
}
|
|
|
|
|
2021-03-29 06:37:45 +00:00
|
|
|
private void onEnable(Intent intent) {
|
|
|
|
boolean enabled = intent.getBooleanExtra("enabled", true);
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
|
|
|
|
prefs.edit().putBoolean("enabled", enabled).apply();
|
|
|
|
onEval(intent);
|
|
|
|
}
|
|
|
|
|
2019-12-12 07:51:48 +00:00
|
|
|
private void onEval(Intent intent) {
|
|
|
|
Bundle command = new Bundle();
|
|
|
|
command.putString("name", "eval");
|
|
|
|
command.putLong("account", intent.getLongExtra("account", -1));
|
|
|
|
liveAccountNetworkState.post(command);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void onReload(Intent intent) {
|
2020-07-12 06:44:50 +00:00
|
|
|
boolean force = intent.getBooleanExtra("force", false);
|
2021-01-16 17:15:45 +00:00
|
|
|
if (force) {
|
2020-03-30 11:07:37 +00:00
|
|
|
lastLost = 0;
|
2021-01-16 18:21:31 +00:00
|
|
|
updateNetworkState(null, "force");
|
2021-01-16 17:15:45 +00:00
|
|
|
}
|
2020-07-12 06:44:50 +00:00
|
|
|
|
2019-12-12 07:51:48 +00:00
|
|
|
Bundle command = new Bundle();
|
|
|
|
command.putString("name", "reload");
|
|
|
|
command.putLong("account", intent.getLongExtra("account", -1));
|
2020-07-12 06:44:50 +00:00
|
|
|
command.putBoolean("force", force);
|
2019-12-12 07:51:48 +00:00
|
|
|
liveAccountNetworkState.post(command);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void onWakeup(Intent intent) {
|
|
|
|
String action = intent.getAction();
|
|
|
|
long account = Long.parseLong(action.split(":")[1]);
|
|
|
|
Core.State state = coreStates.get(account);
|
2020-08-10 14:45:36 +00:00
|
|
|
|
2019-12-12 07:51:48 +00:00
|
|
|
if (state == null)
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### wakeup missing account=" + account);
|
2019-12-12 07:51:48 +00:00
|
|
|
else {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### waking up account=" + account);
|
2020-08-11 05:47:08 +00:00
|
|
|
if (!state.release())
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### waking up failed account=" + account);
|
2019-12-12 07:51:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-30 07:12:36 +00:00
|
|
|
private void onUnsnooze(Intent intent) {
|
|
|
|
String action = intent.getAction();
|
|
|
|
long id = Long.parseLong(action.split(":")[1]);
|
|
|
|
|
|
|
|
executor.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
EntityFolder folder;
|
|
|
|
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
EntityMessage message = db.message().getMessage(id);
|
|
|
|
if (message == null)
|
|
|
|
return;
|
|
|
|
|
|
|
|
folder = db.folder().getFolder(message.folder);
|
|
|
|
if (folder == null)
|
|
|
|
return;
|
|
|
|
|
2021-07-19 14:27:26 +00:00
|
|
|
EntityAccount account = db.account().getAccount(message.account);
|
|
|
|
if (account == null)
|
|
|
|
return;
|
|
|
|
|
2021-03-30 07:12:36 +00:00
|
|
|
if (EntityFolder.OUTBOX.equals(folder.type)) {
|
|
|
|
Log.i("Delayed send id=" + message.id);
|
|
|
|
if (message.ui_snoozed != null) {
|
|
|
|
db.message().setMessageSnoozed(message.id, null);
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, message, EntityOperation.SEND);
|
|
|
|
}
|
|
|
|
} else {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
folder.name + " Unsnooze" +
|
|
|
|
" id=" + message.id +
|
|
|
|
" ui_seen=" + message.ui_seen + "" +
|
|
|
|
" ui_ignored=" + message.ui_ignored +
|
|
|
|
" ui_hide=" + message.ui_hide +
|
|
|
|
" notifying=" + message.notifying +
|
|
|
|
" silent=" + message.ui_silent +
|
|
|
|
" received=" + new Date(message.received) +
|
|
|
|
" sent=" + (message.sent == null ? null : new Date(message.sent)) +
|
|
|
|
" created=" + (account.created == null ? null : new Date(account.created)) +
|
|
|
|
" notify=" + folder.notify +
|
|
|
|
" sync=" + account.synchronize);
|
2021-07-19 14:27:26 +00:00
|
|
|
|
2021-03-30 07:12:36 +00:00
|
|
|
if (folder.notify) {
|
|
|
|
List<EntityAttachment> attachments = db.attachment().getAttachments(id);
|
|
|
|
|
|
|
|
// A new message ID is needed for a new (wearable) notification
|
|
|
|
db.message().deleteMessage(id);
|
|
|
|
|
|
|
|
message.id = null;
|
|
|
|
message.fts = false;
|
2021-07-19 14:27:26 +00:00
|
|
|
message.ui_silent = false;
|
|
|
|
message.notifying = 0;
|
2021-05-01 15:01:08 +00:00
|
|
|
message.stored = new Date().getTime();
|
2021-03-30 07:12:36 +00:00
|
|
|
message.id = db.message().insertMessage(message);
|
|
|
|
|
|
|
|
if (message.content) {
|
|
|
|
File source = EntityMessage.getFile(ServiceSynchronize.this, id);
|
|
|
|
File target = message.getFile(ServiceSynchronize.this);
|
|
|
|
try {
|
|
|
|
Helper.copy(source, target);
|
|
|
|
} catch (IOException ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
db.message().resetMessageContent(message.id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (EntityAttachment attachment : attachments) {
|
|
|
|
File source = attachment.getFile(ServiceSynchronize.this);
|
|
|
|
|
|
|
|
attachment.id = null;
|
|
|
|
attachment.message = message.id;
|
|
|
|
attachment.progress = null;
|
|
|
|
attachment.id = db.attachment().insertAttachment(attachment);
|
|
|
|
|
|
|
|
if (attachment.available) {
|
|
|
|
File target = attachment.getFile(ServiceSynchronize.this);
|
|
|
|
try {
|
|
|
|
Helper.copy(source, target);
|
|
|
|
} catch (IOException ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
db.attachment().setError(attachment.id, Log.formatThrowable(ex, false));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-23 07:04:24 +00:00
|
|
|
// Show thread
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ServiceSynchronize.this);
|
|
|
|
boolean threading = prefs.getBoolean("threading", true);
|
|
|
|
List<EntityMessage> messages = db.message().getMessagesByThread(
|
|
|
|
message.account, message.thread, threading ? null : message.id, null);
|
|
|
|
for (EntityMessage threaded : messages)
|
|
|
|
db.message().setMessageSnoozed(threaded.id, null);
|
|
|
|
|
|
|
|
db.message().setMessageUnsnoozed(message.id, true);
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, message, EntityOperation.SEEN, false, false);
|
2021-03-30 07:12:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (EntityFolder.OUTBOX.equals(folder.type))
|
|
|
|
ServiceSend.start(ServiceSynchronize.this);
|
|
|
|
else
|
|
|
|
ServiceSynchronize.eval(ServiceSynchronize.this, "unsnooze");
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-05-10 12:52:39 +00:00
|
|
|
private void onExists(Intent intent) {
|
|
|
|
String action = intent.getAction();
|
|
|
|
long id = Long.parseLong(action.split(":")[1]);
|
|
|
|
|
|
|
|
executor.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
// Message could have been deleted in the meantime
|
|
|
|
EntityMessage message = db.message().getMessage(id);
|
|
|
|
if (message == null)
|
|
|
|
return;
|
|
|
|
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, message, EntityOperation.EXISTS, true);
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
eval(ServiceSynchronize.this, "exists/delayed");
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-07-25 17:54:28 +00:00
|
|
|
private void onState(Intent intent) {
|
|
|
|
foreground = intent.getBooleanExtra("foreground", false);
|
|
|
|
}
|
|
|
|
|
2021-03-29 13:22:49 +00:00
|
|
|
private void onPoll(Intent intent) {
|
|
|
|
executor.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
DB db = DB.getInstance(ServiceSynchronize.this);
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
List<EntityAccount> accounts = db.account().getPollAccounts(null);
|
|
|
|
for (EntityAccount account : accounts) {
|
|
|
|
List<EntityFolder> folders = db.folder().getSynchronizingFolders(account.id);
|
|
|
|
if (folders.size() > 0)
|
|
|
|
Collections.sort(folders, folders.get(0).getComparator(ServiceSynchronize.this));
|
|
|
|
for (EntityFolder folder : folders)
|
2021-07-30 19:24:48 +00:00
|
|
|
EntityOperation.poll(ServiceSynchronize.this, folder.id);
|
2021-03-29 13:22:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
long now = new Date().getTime();
|
|
|
|
long[] schedule = ServiceSynchronize.getSchedule(ServiceSynchronize.this);
|
2021-06-16 09:48:16 +00:00
|
|
|
boolean scheduled = (schedule == null || (now >= schedule[0] && now < schedule[1]));
|
|
|
|
schedule(ServiceSynchronize.this, scheduled, true, null);
|
2021-03-29 13:22:49 +00:00
|
|
|
|
|
|
|
// Prevent service stop
|
|
|
|
eval(ServiceSynchronize.this, "poll");
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-12-12 07:51:48 +00:00
|
|
|
private void onAlarm(Intent intent) {
|
2020-08-29 09:26:47 +00:00
|
|
|
schedule(this, true);
|
2021-01-17 13:55:21 +00:00
|
|
|
|
|
|
|
Bundle command = new Bundle();
|
2021-02-25 10:45:17 +00:00
|
|
|
command.putString("name", "reload"); // eval will not work if manual sync running
|
2019-12-18 08:29:38 +00:00
|
|
|
command.putBoolean("sync", true);
|
2019-12-12 07:51:48 +00:00
|
|
|
liveAccountNetworkState.post(command);
|
|
|
|
}
|
|
|
|
|
2020-03-25 09:44:50 +00:00
|
|
|
private void onWatchdog(Intent intent) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Scheduling, "Watchdog");
|
2021-06-16 09:48:16 +00:00
|
|
|
schedule(this, false);
|
2021-02-24 07:53:55 +00:00
|
|
|
|
|
|
|
if (lastNetworkState == null || !lastNetworkState.isSuitable())
|
|
|
|
updateNetworkState(null, "watchdog");
|
2021-03-29 19:11:13 +00:00
|
|
|
|
|
|
|
ServiceSend.boot(this);
|
|
|
|
|
|
|
|
scheduleWatchdog(this);
|
2020-03-25 09:44:50 +00:00
|
|
|
}
|
|
|
|
|
2019-12-07 21:06:40 +00:00
|
|
|
private NotificationCompat.Builder getNotificationService(Integer accounts, Integer operations) {
|
|
|
|
if (accounts != null)
|
|
|
|
this.lastAccounts = accounts;
|
|
|
|
if (operations != null)
|
|
|
|
this.lastOperations = operations;
|
2018-10-17 06:11:20 +00:00
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
// Build pending intent
|
2019-03-14 14:57:24 +00:00
|
|
|
Intent why = new Intent(this, ActivityView.class);
|
|
|
|
why.setAction("why");
|
2020-01-13 10:33:34 +00:00
|
|
|
why.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
2021-03-27 17:54:55 +00:00
|
|
|
PendingIntent piWhy = PendingIntentCompat.getActivity(
|
2021-05-22 14:54:17 +00:00
|
|
|
this, ActivityView.PI_WHY, why, PendingIntent.FLAG_UPDATE_CURRENT);
|
2018-08-02 13:33:06 +00:00
|
|
|
|
|
|
|
// Build notification
|
2019-06-23 08:23:49 +00:00
|
|
|
NotificationCompat.Builder builder =
|
|
|
|
new NotificationCompat.Builder(this, "service")
|
|
|
|
.setSmallIcon(R.drawable.baseline_compare_arrows_white_24)
|
|
|
|
.setContentIntent(piWhy)
|
|
|
|
.setAutoCancel(false)
|
|
|
|
.setShowWhen(false)
|
|
|
|
.setPriority(NotificationCompat.PRIORITY_MIN)
|
2020-02-10 19:06:55 +00:00
|
|
|
.setDefaults(0) // disable sound on pre Android 8
|
2019-07-23 09:38:36 +00:00
|
|
|
.setCategory(NotificationCompat.CATEGORY_SERVICE)
|
2019-10-16 13:18:59 +00:00
|
|
|
.setVisibility(NotificationCompat.VISIBILITY_SECRET)
|
|
|
|
.setLocalOnly(true);
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2021-01-26 18:59:40 +00:00
|
|
|
if (lastAccounts > 0)
|
|
|
|
builder.setContentTitle(getResources().getQuantityString(
|
|
|
|
R.plurals.title_notification_synchronizing, lastAccounts, lastAccounts));
|
2021-01-27 08:30:56 +00:00
|
|
|
else
|
|
|
|
builder.setContentTitle(getString(R.string.title_legend_synchronizing));
|
2021-01-26 18:59:40 +00:00
|
|
|
|
2019-12-07 21:06:40 +00:00
|
|
|
if (lastOperations > 0)
|
2019-03-03 09:17:42 +00:00
|
|
|
builder.setContentText(getResources().getQuantityString(
|
2019-12-07 21:06:40 +00:00
|
|
|
R.plurals.title_notification_operations, lastOperations, lastOperations));
|
2018-08-08 11:41:49 +00:00
|
|
|
|
2019-12-07 21:06:40 +00:00
|
|
|
if (lastSuitable == null || !lastSuitable)
|
2019-07-29 10:01:13 +00:00
|
|
|
builder.setSubText(getString(R.string.title_notification_waiting));
|
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
return builder;
|
|
|
|
}
|
|
|
|
|
2021-07-31 18:13:58 +00:00
|
|
|
private NotificationCompat.Builder getNotificationAlert(EntityAccount account, String message) {
|
|
|
|
String title = getString(R.string.title_notification_alert, account.name);
|
|
|
|
|
2019-12-10 10:51:03 +00:00
|
|
|
// Build pending intent
|
2021-07-31 18:13:58 +00:00
|
|
|
Intent intent = new Intent(this, ActivityError.class);
|
|
|
|
intent.setAction("alert:" + account.id);
|
|
|
|
intent.putExtra("type", "alert");
|
|
|
|
intent.putExtra("title", title);
|
|
|
|
intent.putExtra("message", message);
|
2021-08-13 12:33:37 +00:00
|
|
|
intent.putExtra("account", account.id);
|
2021-07-31 18:13:58 +00:00
|
|
|
intent.putExtra("faq", 23);
|
|
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
2021-03-27 17:54:55 +00:00
|
|
|
PendingIntent piAlert = PendingIntentCompat.getActivity(
|
2021-07-31 18:13:58 +00:00
|
|
|
this, ActivityError.PI_ALERT, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
2019-12-10 10:51:03 +00:00
|
|
|
|
|
|
|
// Build notification
|
|
|
|
NotificationCompat.Builder builder =
|
|
|
|
new NotificationCompat.Builder(this, "alerts")
|
|
|
|
.setSmallIcon(R.drawable.baseline_warning_white_24)
|
2021-07-31 18:13:58 +00:00
|
|
|
.setContentTitle(title)
|
2019-12-10 10:51:03 +00:00
|
|
|
.setContentText(message)
|
|
|
|
.setContentIntent(piAlert)
|
|
|
|
.setAutoCancel(false)
|
|
|
|
.setShowWhen(true)
|
|
|
|
.setPriority(NotificationCompat.PRIORITY_MAX)
|
|
|
|
.setOnlyAlertOnce(true)
|
|
|
|
.setCategory(NotificationCompat.CATEGORY_ERROR)
|
|
|
|
.setVisibility(NotificationCompat.VISIBILITY_SECRET)
|
|
|
|
.setStyle(new NotificationCompat.BigTextStyle()
|
|
|
|
.bigText(message));
|
|
|
|
|
|
|
|
return builder;
|
|
|
|
}
|
|
|
|
|
2020-07-12 06:44:50 +00:00
|
|
|
private void monitorAccount(
|
|
|
|
final EntityAccount account, final Core.State state,
|
|
|
|
final boolean sync, final boolean force) throws NoSuchProviderException {
|
2018-12-09 17:49:52 +00:00
|
|
|
final PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
|
2018-12-02 13:19:54 +00:00
|
|
|
final PowerManager.WakeLock wlAccount = pm.newWakeLock(
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, BuildConfig.APPLICATION_ID + ":account." + account.id);
|
2019-05-18 06:02:45 +00:00
|
|
|
final PowerManager.WakeLock wlFolder = pm.newWakeLock(
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, BuildConfig.APPLICATION_ID + ":account." + account.id + ".folder");
|
|
|
|
final PowerManager.WakeLock wlMessage = pm.newWakeLock(
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, BuildConfig.APPLICATION_ID + ":account." + account.id + ".message");
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
try {
|
2018-12-02 13:19:54 +00:00
|
|
|
wlAccount.acquire();
|
2018-10-10 07:26:04 +00:00
|
|
|
|
2020-12-02 15:58:32 +00:00
|
|
|
boolean forced = false;
|
2020-03-08 10:08:28 +00:00
|
|
|
final DB db = DB.getInstance(this);
|
|
|
|
|
2021-04-05 06:23:00 +00:00
|
|
|
Long currentThread = Thread.currentThread().getId();
|
|
|
|
Long accountThread = currentThread;
|
|
|
|
db.account().setAccountThread(account.id, accountThread);
|
2020-03-08 10:08:28 +00:00
|
|
|
|
2019-12-09 11:43:43 +00:00
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
|
|
if (account.notify)
|
2020-10-31 10:11:35 +00:00
|
|
|
account.createNotificationChannel(this);
|
2019-12-09 11:43:43 +00:00
|
|
|
else
|
2020-10-31 10:11:35 +00:00
|
|
|
account.deleteNotificationChannel(this);
|
2019-12-09 11:43:43 +00:00
|
|
|
}
|
|
|
|
|
2020-10-29 09:45:24 +00:00
|
|
|
int fast_fails = 0;
|
|
|
|
long first_fail = 0;
|
2020-10-30 07:34:13 +00:00
|
|
|
Throwable last_fail = null;
|
2019-12-11 10:43:32 +00:00
|
|
|
state.setBackoff(CONNECT_BACKOFF_START);
|
2020-11-14 06:55:26 +00:00
|
|
|
if (account.backoff_until != null)
|
|
|
|
db.account().setAccountBackoff(account.id, null);
|
2021-04-05 06:23:00 +00:00
|
|
|
while (state.isRunning() && currentThread.equals(accountThread)) {
|
2020-09-21 19:46:39 +00:00
|
|
|
state.reset();
|
2020-03-08 10:08:28 +00:00
|
|
|
Log.i(account.name + " run thread=" + currentThread);
|
2018-10-10 07:26:04 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
final ObjectHolder<TwoStateOwner> cowner = new ObjectHolder<>();
|
2020-09-23 06:19:28 +00:00
|
|
|
final ExecutorService executor =
|
|
|
|
Helper.getBackgroundExecutor(1, "account_" + account.id);
|
2020-09-22 10:47:49 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
// Debug
|
2019-03-06 10:18:57 +00:00
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
|
2020-12-20 07:10:36 +00:00
|
|
|
boolean subscriptions = prefs.getBoolean("subscriptions", false);
|
2019-04-06 07:56:37 +00:00
|
|
|
boolean debug = (prefs.getBoolean("debug", false) || BuildConfig.DEBUG);
|
2018-10-10 07:26:04 +00:00
|
|
|
|
2020-01-29 20:06:45 +00:00
|
|
|
final EmailService iservice = new EmailService(
|
2020-08-23 07:28:10 +00:00
|
|
|
this, account.getProtocol(), account.realm, account.encryption, account.insecure, debug);
|
2019-07-29 09:17:12 +00:00
|
|
|
iservice.setPartialFetch(account.partial_fetch);
|
2019-10-09 12:01:26 +00:00
|
|
|
iservice.setIgnoreBodyStructureSize(account.ignore_size);
|
2019-11-23 12:48:59 +00:00
|
|
|
if (account.protocol != EntityAccount.TYPE_IMAP)
|
2020-01-21 14:15:48 +00:00
|
|
|
iservice.setLeaveOnServer(account.leave_on_server);
|
2020-02-22 14:44:58 +00:00
|
|
|
|
2021-07-31 11:25:14 +00:00
|
|
|
final Date lastStillHere = new Date(0);
|
2020-02-22 14:44:58 +00:00
|
|
|
|
2019-12-09 15:32:37 +00:00
|
|
|
iservice.setListener(new StoreListener() {
|
|
|
|
@Override
|
|
|
|
public void notification(StoreEvent e) {
|
2019-12-11 10:43:32 +00:00
|
|
|
String message = e.getMessage();
|
|
|
|
if (TextUtils.isEmpty(message))
|
|
|
|
message = "?";
|
2020-02-22 13:52:26 +00:00
|
|
|
if (e.getMessageType() == StoreEvent.NOTICE) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " notice: " + message);
|
2020-02-22 13:52:26 +00:00
|
|
|
|
2020-12-26 15:41:34 +00:00
|
|
|
if ("Still here".equals(message) &&
|
|
|
|
!account.isTransient(ServiceSynchronize.this)) {
|
2021-07-31 11:25:14 +00:00
|
|
|
long now = new Date().getTime();
|
|
|
|
long last = lastStillHere.getTime();
|
|
|
|
if (last > 0) {
|
|
|
|
long elapsed = now - last;
|
|
|
|
if (elapsed < STILL_THERE_THRESHOLD)
|
|
|
|
optimizeAccount(account, "'" + message + "'" +
|
|
|
|
" elapsed=" + elapsed + " ms");
|
|
|
|
}
|
|
|
|
lastStillHere.setTime(now);
|
2020-02-22 13:52:26 +00:00
|
|
|
}
|
|
|
|
} else
|
2019-12-09 15:32:37 +00:00
|
|
|
try {
|
|
|
|
wlFolder.acquire();
|
|
|
|
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " alert: " + message);
|
2019-12-09 15:32:37 +00:00
|
|
|
|
2020-03-24 10:29:01 +00:00
|
|
|
if (!ConnectionHelper.isMaxConnections(message))
|
2020-02-22 21:09:46 +00:00
|
|
|
try {
|
|
|
|
NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
2021-07-15 16:36:39 +00:00
|
|
|
nm.notify("alert:" + account.id,
|
|
|
|
NotificationHelper.NOTIFICATION_TAGGED,
|
2021-07-31 18:13:58 +00:00
|
|
|
getNotificationAlert(account, message).build());
|
2020-02-22 21:09:46 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
}
|
2019-12-09 15:32:37 +00:00
|
|
|
} finally {
|
|
|
|
wlFolder.release();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2019-03-02 12:55:13 +00:00
|
|
|
|
2020-11-17 17:29:02 +00:00
|
|
|
final Map<EntityFolder, IMAPFolder> mapFolders = new LinkedHashMap<>();
|
2018-10-10 07:26:04 +00:00
|
|
|
List<Thread> idlers = new ArrayList<>();
|
|
|
|
try {
|
2019-07-28 19:45:29 +00:00
|
|
|
// Initiate connection
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " connecting");
|
2019-07-28 19:45:29 +00:00
|
|
|
db.folder().setFolderStates(account.id, null);
|
|
|
|
db.account().setAccountState(account.id, "connecting");
|
|
|
|
|
|
|
|
try {
|
2021-07-17 10:42:02 +00:00
|
|
|
iservice.connect(account);
|
2021-07-31 11:25:14 +00:00
|
|
|
lastStillHere.setTime(0);
|
2019-07-28 19:45:29 +00:00
|
|
|
} catch (Throwable ex) {
|
2019-12-09 11:24:42 +00:00
|
|
|
// Immediately report auth errors
|
2020-01-13 12:18:49 +00:00
|
|
|
if (ex instanceof AuthenticationFailedException) {
|
2020-07-05 16:43:54 +00:00
|
|
|
if (ConnectionHelper.isIoError(ex)) {
|
|
|
|
if (!BuildConfig.PLAY_STORE_RELEASE)
|
|
|
|
Log.e(ex);
|
|
|
|
} else {
|
2020-02-24 09:35:34 +00:00
|
|
|
Log.e(ex);
|
2020-02-22 21:09:46 +00:00
|
|
|
try {
|
2021-01-09 09:06:11 +00:00
|
|
|
state.setBackoff(2 * CONNECT_BACKOFF_ALARM_MAX * 60);
|
2020-02-22 21:09:46 +00:00
|
|
|
NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
2021-07-15 16:36:39 +00:00
|
|
|
nm.notify("receive:" + account.id,
|
|
|
|
NotificationHelper.NOTIFICATION_TAGGED,
|
2021-07-31 18:13:58 +00:00
|
|
|
Core.getNotificationError(this, "error", account, 0, ex)
|
2020-02-22 21:09:46 +00:00
|
|
|
.build());
|
|
|
|
} catch (Throwable ex1) {
|
|
|
|
Log.w(ex1);
|
|
|
|
}
|
2020-01-13 12:18:49 +00:00
|
|
|
throw ex;
|
|
|
|
}
|
2019-07-28 19:45:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
throw ex;
|
|
|
|
}
|
|
|
|
|
2020-08-29 10:38:06 +00:00
|
|
|
// https://tools.ietf.org/html/rfc2177
|
2019-09-19 15:41:26 +00:00
|
|
|
final boolean capIdle = iservice.hasCapability("IDLE");
|
2021-06-04 13:54:29 +00:00
|
|
|
final boolean capUtf8 =
|
|
|
|
iservice.hasCapability("UTF8=ACCEPT") ||
|
|
|
|
iservice.hasCapability("UTF8=ONLY");
|
2021-01-03 11:41:16 +00:00
|
|
|
final boolean capNotify = iservice.hasCapability("NOTIFY");
|
2021-08-09 05:28:07 +00:00
|
|
|
|
2021-08-08 12:13:31 +00:00
|
|
|
String capabilities = TextUtils.join(" ", iservice.getCapabilities());
|
|
|
|
if (capabilities.length() > 500)
|
|
|
|
capabilities = capabilities.substring(0, 500) + "...";
|
2020-12-02 13:39:48 +00:00
|
|
|
|
2021-08-09 05:28:07 +00:00
|
|
|
Log.i(account.name + " idle=" + capIdle);
|
|
|
|
if (!capIdle || account.poll_interval < OPTIMIZE_KEEP_ALIVE_INTERVAL)
|
|
|
|
optimizeAccount(account, "IDLE");
|
|
|
|
|
2019-07-28 19:45:29 +00:00
|
|
|
db.account().setAccountState(account.id, "connected");
|
2021-08-08 12:13:31 +00:00
|
|
|
db.account().setAccountCapabilities(account.id, capabilities, capIdle, capUtf8);
|
2019-07-28 19:45:29 +00:00
|
|
|
db.account().setAccountError(account.id, null);
|
|
|
|
db.account().setAccountWarning(account.id, null);
|
2020-12-02 11:00:35 +00:00
|
|
|
|
|
|
|
Store istore = iservice.getStore();
|
|
|
|
if (istore instanceof IMAPStore) {
|
|
|
|
Map<String, String> caps = ((IMAPStore) istore).getCapabilities();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " connected" +
|
|
|
|
" caps=" + (caps == null ? null : TextUtils.join(" ", caps.keySet())));
|
2020-12-02 11:00:35 +00:00
|
|
|
} else
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " connected");
|
2019-07-28 19:45:29 +00:00
|
|
|
|
2020-07-03 07:57:43 +00:00
|
|
|
db.account().setAccountMaxSize(account.id, iservice.getMaxSize());
|
2020-12-29 17:46:17 +00:00
|
|
|
if (istore instanceof IMAPStore)
|
2021-06-28 09:31:19 +00:00
|
|
|
updateQuota(this, ((IMAPStore) iservice.getStore()), account);
|
2020-07-03 07:57:43 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
// Listen for folder events
|
2019-07-28 19:45:29 +00:00
|
|
|
iservice.getStore().addFolderListener(new FolderAdapter() {
|
2018-10-10 07:26:04 +00:00
|
|
|
@Override
|
|
|
|
public void folderCreated(FolderEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.acquire();
|
2019-05-25 14:32:08 +00:00
|
|
|
|
|
|
|
String name = e.getFolder().getFullName();
|
|
|
|
Log.i("Folder created=" + name);
|
|
|
|
if (db.folder().getFolderByName(account.id, name) == null)
|
2020-03-30 11:07:37 +00:00
|
|
|
reload(ServiceSynchronize.this, account.id, false, "folder created");
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.release();
|
2018-10-10 07:26:04 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
@Override
|
|
|
|
public void folderRenamed(FolderEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.acquire();
|
2018-09-14 06:28:23 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
String old = e.getFolder().getFullName();
|
|
|
|
String name = e.getNewFolder().getFullName();
|
2019-05-25 14:32:08 +00:00
|
|
|
Log.i("Folder renamed from=" + old + " to=" + name);
|
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
int count = db.folder().renameFolder(account.id, old, name);
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i("Renamed to " + name + " count=" + count);
|
2021-07-17 14:10:26 +00:00
|
|
|
if (count != 0)
|
2020-03-30 11:07:37 +00:00
|
|
|
reload(ServiceSynchronize.this, account.id, false, "folder renamed");
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.release();
|
2018-10-10 07:26:04 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
@Override
|
|
|
|
public void folderDeleted(FolderEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.acquire();
|
2019-05-25 14:32:08 +00:00
|
|
|
|
|
|
|
String name = e.getFolder().getFullName();
|
|
|
|
Log.i("Folder deleted=" + name);
|
|
|
|
if (db.folder().getFolderByName(account.id, name) != null)
|
2020-03-30 11:07:37 +00:00
|
|
|
reload(ServiceSynchronize.this, account.id, false, "folder deleted");
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlFolder.release();
|
2018-10-10 07:26:04 +00:00
|
|
|
}
|
|
|
|
}
|
2020-12-02 13:39:48 +00:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void folderChanged(FolderEvent e) {
|
|
|
|
try {
|
|
|
|
wlFolder.acquire();
|
|
|
|
|
|
|
|
String name = e.getFolder().getFullName();
|
|
|
|
EntityLog.log(ServiceSynchronize.this, "Folder changed=" + name);
|
|
|
|
EntityFolder folder = db.folder().getFolderByName(account.id, name);
|
2021-01-24 08:19:00 +00:00
|
|
|
if (folder != null && folder.selectable)
|
2020-12-02 13:39:48 +00:00
|
|
|
EntityOperation.sync(ServiceSynchronize.this, folder.id, false);
|
|
|
|
} finally {
|
|
|
|
wlFolder.release();
|
|
|
|
}
|
|
|
|
}
|
2018-10-10 07:26:04 +00:00
|
|
|
});
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
// Update folder list
|
2019-11-23 12:48:59 +00:00
|
|
|
if (account.protocol == EntityAccount.TYPE_IMAP)
|
2020-12-02 15:58:32 +00:00
|
|
|
Core.onSynchronizeFolders(this, account, iservice.getStore(), state, force && !forced);
|
2018-08-04 22:35:47 +00:00
|
|
|
|
2018-12-05 09:25:35 +00:00
|
|
|
// Open synchronizing folders
|
2019-07-07 07:25:52 +00:00
|
|
|
List<EntityFolder> folders = db.folder().getFolders(account.id, false, true);
|
2020-02-01 07:19:41 +00:00
|
|
|
if (folders.size() > 0)
|
2020-10-31 10:11:35 +00:00
|
|
|
Collections.sort(folders, folders.get(0).getComparator(this));
|
2019-06-24 06:34:17 +00:00
|
|
|
|
2019-05-21 13:21:03 +00:00
|
|
|
for (final EntityFolder folder : folders) {
|
2020-12-26 15:32:45 +00:00
|
|
|
if (folder.selectable && folder.synchronize && !folder.poll && capIdle && sync) {
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i(account.name + " sync folder " + folder.name);
|
2018-08-22 05:31:00 +00:00
|
|
|
|
2018-12-05 09:25:35 +00:00
|
|
|
db.folder().setFolderState(folder.id, "connecting");
|
2018-08-22 05:31:00 +00:00
|
|
|
|
2019-07-28 19:45:29 +00:00
|
|
|
final IMAPFolder ifolder = (IMAPFolder) iservice.getStore().getFolder(folder.name);
|
2019-12-11 10:48:57 +00:00
|
|
|
mapFolders.put(folder, ifolder);
|
2018-12-05 09:25:35 +00:00
|
|
|
try {
|
2019-07-07 07:25:52 +00:00
|
|
|
if (BuildConfig.DEBUG && "Postausgang".equals(folder.name))
|
|
|
|
throw new ReadOnlyFolderException(ifolder);
|
2018-12-05 09:25:35 +00:00
|
|
|
ifolder.open(Folder.READ_WRITE);
|
2019-07-25 05:17:27 +00:00
|
|
|
db.folder().setFolderReadOnly(folder.id, ifolder.getUIDNotSticky());
|
2019-04-29 19:54:49 +00:00
|
|
|
} catch (ReadOnlyFolderException ex) {
|
2019-04-30 07:06:32 +00:00
|
|
|
Log.w(folder.name + " read only");
|
2019-04-29 19:54:49 +00:00
|
|
|
try {
|
|
|
|
ifolder.open(Folder.READ_ONLY);
|
2019-04-30 07:06:32 +00:00
|
|
|
db.folder().setFolderReadOnly(folder.id, true);
|
2019-12-08 08:31:09 +00:00
|
|
|
} catch (Throwable ex1) {
|
2019-12-06 07:50:46 +00:00
|
|
|
db.folder().setFolderError(folder.id, Log.formatThrowable(ex1));
|
2019-12-08 08:31:09 +00:00
|
|
|
throw ex1;
|
2019-04-29 19:54:49 +00:00
|
|
|
}
|
2019-05-25 14:45:46 +00:00
|
|
|
} catch (FolderNotFoundException ex) {
|
2019-09-17 19:25:41 +00:00
|
|
|
Log.w(folder.name, ex);
|
2020-10-20 14:18:43 +00:00
|
|
|
db.folder().setFolderError(folder.id, Log.formatThrowable(ex));
|
|
|
|
db.folder().setFolderSynchronize(folder.id, false);
|
2019-05-25 14:45:46 +00:00
|
|
|
continue;
|
2018-12-05 09:25:35 +00:00
|
|
|
} catch (Throwable ex) {
|
2019-12-06 07:50:46 +00:00
|
|
|
db.folder().setFolderError(folder.id, Log.formatThrowable(ex));
|
2020-10-23 05:39:37 +00:00
|
|
|
if (EntityFolder.INBOX.equals(folder.type))
|
|
|
|
throw ex;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
javax.mail.MessagingException: D2 NO Mailbox does not exist, or must be subscribed to.;
|
|
|
|
nested exception is:
|
|
|
|
com.sun.mail.iap.CommandFailedException: D2 NO Mailbox does not exist, or must be subscribed to.
|
|
|
|
javax.mail.MessagingException: D2 NO Mailbox does not exist, or must be subscribed to.;
|
|
|
|
nested exception is:
|
|
|
|
com.sun.mail.iap.CommandFailedException: D2 NO Mailbox does not exist, or must be subscribed to.
|
|
|
|
at com.sun.mail.imap.IMAPFolder.open(SourceFile:61)
|
|
|
|
at com.sun.mail.imap.IMAPFolder.open(SourceFile:1)
|
|
|
|
at eu.faircode.email.ServiceSynchronize.monitorAccount(SourceFile:63)
|
|
|
|
at eu.faircode.email.ServiceSynchronize.access$900(SourceFile:1)
|
|
|
|
at eu.faircode.email.ServiceSynchronize$4$1.run(SourceFile:1)
|
|
|
|
at java.lang.Thread.run(Thread.java:919)
|
|
|
|
Caused by: com.sun.mail.iap.CommandFailedException: D2 NO Mailbox does not exist, or must be subscribed to.
|
|
|
|
at com.sun.mail.iap.Protocol.handleResult(SourceFile:8)
|
|
|
|
at com.sun.mail.imap.protocol.IMAPProtocol.select(SourceFile:19)
|
|
|
|
at com.sun.mail.imap.IMAPFolder.open(SourceFile:16)
|
|
|
|
*/
|
2018-12-05 09:25:35 +00:00
|
|
|
}
|
2018-08-22 05:31:00 +00:00
|
|
|
|
2018-12-05 09:25:35 +00:00
|
|
|
db.folder().setFolderState(folder.id, "connected");
|
|
|
|
db.folder().setFolderError(folder.id, null);
|
2018-11-29 13:00:46 +00:00
|
|
|
|
2020-08-28 10:02:08 +00:00
|
|
|
if (capIdle != MessageHelper.hasCapability(ifolder, "IDLE"))
|
|
|
|
Log.e("Conflicting IDLE=" + capIdle + " host=" + account.host);
|
|
|
|
|
2020-08-08 09:51:41 +00:00
|
|
|
int count = MessageHelper.getMessageCount(ifolder);
|
2019-03-09 08:20:46 +00:00
|
|
|
db.folder().setFolderTotal(folder.id, count < 0 ? null : count);
|
|
|
|
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i(account.name + " folder " + folder.name + " flags=" + ifolder.getPermanentFlags());
|
2018-11-25 12:34:08 +00:00
|
|
|
|
2018-12-05 09:25:35 +00:00
|
|
|
// Listen for new and deleted messages
|
|
|
|
ifolder.addMessageCountListener(new MessageCountAdapter() {
|
|
|
|
@Override
|
|
|
|
public void messagesAdded(MessageCountEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.acquire();
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i(folder.name + " messages added");
|
2018-12-05 09:25:35 +00:00
|
|
|
|
2020-01-25 17:48:06 +00:00
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
2020-11-06 06:48:34 +00:00
|
|
|
for (Message imessage : e.getMessages()) {
|
|
|
|
long uid = ifolder.getUID(imessage);
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, folder, EntityOperation.FETCH, uid);
|
|
|
|
}
|
2020-01-25 17:48:06 +00:00
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
2019-09-17 11:38:23 +00:00
|
|
|
}
|
2020-11-10 19:06:02 +00:00
|
|
|
|
|
|
|
Thread.sleep(FETCH_YIELD_DURATION);
|
2018-12-05 09:25:35 +00:00
|
|
|
} catch (Throwable ex) {
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.e(folder.name, ex);
|
2021-08-15 18:32:34 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this,
|
2021-05-01 13:26:02 +00:00
|
|
|
folder.name + " added " + Log.formatThrowable(ex, false));
|
2020-09-21 19:46:39 +00:00
|
|
|
state.error(ex);
|
2018-12-05 09:25:35 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.release();
|
2018-12-05 09:25:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void messagesRemoved(MessageCountEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.acquire();
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i(folder.name + " messages removed");
|
2019-09-17 11:38:23 +00:00
|
|
|
|
2020-01-25 17:48:06 +00:00
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
2020-11-06 06:48:34 +00:00
|
|
|
for (Message imessage : e.getMessages()) {
|
|
|
|
long uid = ifolder.getUID(imessage);
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, folder, EntityOperation.FETCH, uid, true);
|
|
|
|
}
|
2020-01-25 17:48:06 +00:00
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
2019-09-17 11:38:23 +00:00
|
|
|
}
|
2020-11-10 19:06:02 +00:00
|
|
|
|
|
|
|
Thread.sleep(FETCH_YIELD_DURATION);
|
2018-12-05 09:25:35 +00:00
|
|
|
} catch (Throwable ex) {
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.e(folder.name, ex);
|
2021-08-15 18:32:34 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this,
|
2021-05-01 13:26:02 +00:00
|
|
|
folder.name + " removed " + Log.formatThrowable(ex, false));
|
2020-09-21 19:46:39 +00:00
|
|
|
state.error(ex);
|
2018-12-05 09:25:35 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.release();
|
2018-12-05 09:25:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
// Flags (like "seen") at the remote could be changed while synchronizing
|
|
|
|
|
|
|
|
// Listen for changed messages
|
|
|
|
ifolder.addMessageChangedListener(new MessageChangedListener() {
|
|
|
|
@Override
|
|
|
|
public void messageChanged(MessageChangedEvent e) {
|
|
|
|
try {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.acquire();
|
2019-09-17 11:38:23 +00:00
|
|
|
Log.i(folder.name + " message changed");
|
|
|
|
|
|
|
|
long uid = ifolder.getUID(e.getMessage());
|
|
|
|
EntityOperation.queue(ServiceSynchronize.this, folder, EntityOperation.FETCH, uid);
|
2020-11-10 19:06:02 +00:00
|
|
|
|
|
|
|
Thread.sleep(FETCH_YIELD_DURATION);
|
2018-12-05 09:25:35 +00:00
|
|
|
} catch (Throwable ex) {
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.e(folder.name, ex);
|
2021-08-15 18:32:34 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this,
|
2021-05-01 13:26:02 +00:00
|
|
|
folder.name + " changed " + Log.formatThrowable(ex, false));
|
2020-09-21 19:46:39 +00:00
|
|
|
state.error(ex);
|
2018-12-05 09:25:35 +00:00
|
|
|
} finally {
|
2019-05-18 06:02:45 +00:00
|
|
|
wlMessage.release();
|
2018-12-02 13:19:54 +00:00
|
|
|
}
|
2018-08-15 19:34:22 +00:00
|
|
|
}
|
2018-12-05 09:25:35 +00:00
|
|
|
});
|
2018-10-10 07:26:04 +00:00
|
|
|
|
2018-12-05 09:25:35 +00:00
|
|
|
// Idle folder
|
2021-02-24 07:14:58 +00:00
|
|
|
Thread idler = new Thread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
Log.i(folder.name + " start idle");
|
2021-02-25 09:12:28 +00:00
|
|
|
while (ifolder.isOpen() && state.isRunning() && state.isRecoverable()) {
|
2021-02-24 07:14:58 +00:00
|
|
|
Log.i(folder.name + " do idle");
|
|
|
|
ifolder.idle(false);
|
|
|
|
state.activity();
|
2018-10-10 07:26:04 +00:00
|
|
|
}
|
2021-02-24 07:14:58 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(folder.name, ex);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Account,
|
2021-05-01 13:26:02 +00:00
|
|
|
folder.name + " idle " + Log.formatThrowable(ex, false));
|
2021-02-24 07:14:58 +00:00
|
|
|
state.error(new FolderClosedException(ifolder, "IDLE", new Exception(ex)));
|
|
|
|
} finally {
|
|
|
|
Log.i(folder.name + " end idle");
|
2018-08-21 19:08:51 +00:00
|
|
|
}
|
2021-02-24 07:14:58 +00:00
|
|
|
}
|
|
|
|
}, "idler." + folder.id);
|
|
|
|
idler.setPriority(THREAD_PRIORITY_BACKGROUND);
|
|
|
|
idler.start();
|
|
|
|
idlers.add(idler);
|
2018-12-02 13:19:54 +00:00
|
|
|
|
2020-12-26 15:32:45 +00:00
|
|
|
EntityOperation.sync(this, folder.id, false, force && !forced);
|
2020-12-02 13:39:48 +00:00
|
|
|
|
2020-12-20 07:10:36 +00:00
|
|
|
if (capNotify && subscriptions && EntityFolder.INBOX.equals(folder.type))
|
2020-12-02 13:39:48 +00:00
|
|
|
ifolder.doCommand(new IMAPFolder.ProtocolCommand() {
|
|
|
|
@Override
|
|
|
|
public Object doCommand(IMAPProtocol protocol) throws ProtocolException {
|
|
|
|
EntityLog.log(ServiceSynchronize.this, account.name + " NOTIFY enable");
|
|
|
|
|
|
|
|
// https://tools.ietf.org/html/rfc5465
|
|
|
|
Argument arg = new Argument();
|
2020-12-03 11:38:22 +00:00
|
|
|
arg.writeAtom("SET STATUS" +
|
|
|
|
" (selected (MessageNew (uid) MessageExpunge FlagChange))" +
|
|
|
|
" (subscribed (MessageNew MessageExpunge FlagChange))");
|
2020-12-02 13:39:48 +00:00
|
|
|
|
|
|
|
Response[] responses = protocol.command("NOTIFY", arg);
|
|
|
|
|
|
|
|
if (responses.length == 0)
|
|
|
|
throw new ProtocolException("No response");
|
|
|
|
if (!responses[responses.length - 1].isOK())
|
|
|
|
throw new ProtocolException(responses[responses.length - 1]);
|
|
|
|
|
|
|
|
for (int i = 0; i < responses.length - 1; i++) {
|
|
|
|
EntityLog.log(ServiceSynchronize.this, account.name + " " + responses[i]);
|
|
|
|
if (responses[i] instanceof IMAPResponse) {
|
|
|
|
IMAPResponse ir = (IMAPResponse) responses[i];
|
|
|
|
if (ir.keyEquals("STATUS")) {
|
|
|
|
String mailbox = ir.readAtomString();
|
|
|
|
EntityFolder f = db.folder().getFolderByName(account.id, mailbox);
|
|
|
|
if (f != null)
|
|
|
|
EntityOperation.sync(ServiceSynchronize.this, f.id, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
});
|
2020-10-26 10:47:42 +00:00
|
|
|
} else {
|
2019-05-21 13:21:03 +00:00
|
|
|
mapFolders.put(folder, null);
|
2020-10-26 10:47:42 +00:00
|
|
|
db.folder().setFolderState(folder.id, null);
|
2020-10-26 12:21:43 +00:00
|
|
|
if (!capIdle && !folder.poll) {
|
|
|
|
folder.poll = true;
|
|
|
|
db.folder().setFolderPoll(folder.id, folder.poll);
|
|
|
|
}
|
2020-10-26 10:47:42 +00:00
|
|
|
}
|
2020-10-04 14:57:19 +00:00
|
|
|
}
|
2018-08-04 22:35:47 +00:00
|
|
|
|
2020-12-02 15:58:32 +00:00
|
|
|
forced = true;
|
|
|
|
|
2020-12-28 15:10:33 +00:00
|
|
|
final Runnable purge = new Runnable() {
|
2020-12-26 12:09:47 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
executor.submit(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
2020-12-31 14:31:00 +00:00
|
|
|
wlAccount.acquire();
|
2020-12-28 15:10:33 +00:00
|
|
|
|
2020-12-28 12:58:54 +00:00
|
|
|
// Close cached connections
|
2020-12-26 12:09:47 +00:00
|
|
|
Log.i(account.name + " Empty connection pool");
|
|
|
|
((IMAPStore) istore).emptyConnectionPool(false);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2020-12-28 15:10:33 +00:00
|
|
|
} finally {
|
2020-12-31 14:31:00 +00:00
|
|
|
wlAccount.release();
|
2020-12-26 12:09:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
Log.i(account.name + " observing operations");
|
|
|
|
getMainHandler().post(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
cowner.value = new TwoStateOwner(ServiceSynchronize.this, account.name);
|
|
|
|
cowner.value.start();
|
2019-05-22 07:33:25 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
db.operation().liveOperations(account.id).observe(cowner.value, new Observer<List<TupleOperationEx>>() {
|
|
|
|
private List<Long> handling = new ArrayList<>();
|
|
|
|
private final Map<TupleOperationEx.PartitionKey, List<TupleOperationEx>> partitions = new HashMap<>();
|
2020-01-27 09:24:47 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
private final PowerManager.WakeLock wlOperations = pm.newWakeLock(
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, BuildConfig.APPLICATION_ID + ":operations." + account.id);
|
2020-01-27 09:24:47 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
@Override
|
|
|
|
public void onChanged(final List<TupleOperationEx> _operations) {
|
|
|
|
// Get new operations
|
2020-11-06 08:25:00 +00:00
|
|
|
List<Long> all = new ArrayList<>();
|
2020-11-17 17:29:02 +00:00
|
|
|
Map<Long, List<TupleOperationEx>> added = new LinkedHashMap<>();
|
2020-10-04 14:57:19 +00:00
|
|
|
for (TupleOperationEx op : _operations) {
|
2020-11-06 08:25:00 +00:00
|
|
|
all.add(op.id);
|
2020-10-04 14:57:19 +00:00
|
|
|
if (!handling.contains(op.id)) {
|
2020-11-06 08:25:00 +00:00
|
|
|
if (!added.containsKey(op.folder))
|
|
|
|
added.put(op.folder, new ArrayList<>());
|
|
|
|
added.get(op.folder).add(op);
|
2020-10-04 14:57:19 +00:00
|
|
|
}
|
|
|
|
}
|
2020-11-06 08:25:00 +00:00
|
|
|
handling = all;
|
|
|
|
|
2020-12-26 12:09:47 +00:00
|
|
|
if (istore instanceof IMAPStore) {
|
|
|
|
getMainHandler().removeCallbacks(purge);
|
|
|
|
if (handling.size() == 0)
|
|
|
|
getMainHandler().postDelayed(purge, PURGE_DELAY);
|
|
|
|
}
|
|
|
|
|
2020-11-06 08:25:00 +00:00
|
|
|
for (Long fid : added.keySet()) {
|
|
|
|
EntityFolder found = null;
|
|
|
|
for (EntityFolder f : mapFolders.keySet())
|
|
|
|
if (Objects.equals(fid, f.id)) {
|
|
|
|
found = f;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (found == null) {
|
|
|
|
Log.w(account.name + " folder not found operation=" + fid);
|
|
|
|
continue;
|
|
|
|
}
|
2020-10-04 14:57:19 +00:00
|
|
|
|
2020-11-06 08:25:00 +00:00
|
|
|
final EntityFolder folder = found;
|
2020-10-04 14:57:19 +00:00
|
|
|
Log.i(folder.name + " queuing operations=" + added.size() +
|
|
|
|
" init=" + folder.initialize + " poll=" + folder.poll);
|
|
|
|
|
|
|
|
// Partition operations by priority
|
|
|
|
boolean offline = (mapFolders.get(folder) == null);
|
|
|
|
List<TupleOperationEx.PartitionKey> keys = new ArrayList<>();
|
|
|
|
synchronized (partitions) {
|
2020-11-06 08:25:00 +00:00
|
|
|
for (TupleOperationEx op : added.get(folder.id)) {
|
2020-10-04 14:57:19 +00:00
|
|
|
TupleOperationEx.PartitionKey key = op.getPartitionKey(offline);
|
|
|
|
|
|
|
|
if (!partitions.containsKey(key)) {
|
|
|
|
partitions.put(key, new ArrayList<>());
|
|
|
|
keys.add(key);
|
2020-01-27 12:12:57 +00:00
|
|
|
}
|
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
partitions.get(key).add(op);
|
|
|
|
}
|
|
|
|
}
|
2020-01-25 11:58:21 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
Collections.sort(keys, new Comparator<TupleOperationEx.PartitionKey>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TupleOperationEx.PartitionKey k1, TupleOperationEx.PartitionKey k2) {
|
|
|
|
Integer p1 = k1.getPriority();
|
|
|
|
Integer p2 = k2.getPriority();
|
|
|
|
int priority = p1.compareTo(p2);
|
|
|
|
if (priority == 0) {
|
|
|
|
Long o1 = k1.getOrder();
|
|
|
|
Long o2 = k2.getOrder();
|
|
|
|
return o1.compareTo(o2);
|
|
|
|
} else
|
|
|
|
return priority;
|
|
|
|
}
|
|
|
|
});
|
2020-09-22 12:04:26 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
for (TupleOperationEx.PartitionKey key : keys) {
|
|
|
|
synchronized (partitions) {
|
|
|
|
Log.i(folder.name +
|
|
|
|
" queuing partition=" + key +
|
|
|
|
" operations=" + partitions.get(key).size());
|
|
|
|
}
|
2020-01-27 09:24:47 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
final long sequence = state.getSequence(folder.id, key.getPriority());
|
2018-08-04 22:35:47 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
executor.submit(new Helper.PriorityRunnable(key.getPriority(), key.getOrder()) {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
super.run();
|
|
|
|
try {
|
|
|
|
wlOperations.acquire();
|
|
|
|
|
|
|
|
List<TupleOperationEx> partition;
|
|
|
|
synchronized (partitions) {
|
|
|
|
partition = partitions.get(key);
|
|
|
|
partitions.remove(key);
|
|
|
|
}
|
2018-08-26 08:33:22 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
Log.i(folder.name +
|
|
|
|
" executing partition=" + key +
|
|
|
|
" operations=" + partition.size());
|
2018-09-03 09:34:13 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
// Get folder
|
|
|
|
Folder ifolder = mapFolders.get(folder); // null when polling
|
2020-12-17 14:05:44 +00:00
|
|
|
boolean canOpen = (EntityFolder.INBOX.equals(folder.type) ||
|
|
|
|
(account.protocol == EntityAccount.TYPE_IMAP && !folder.local));
|
2020-10-04 14:57:19 +00:00
|
|
|
final boolean shouldClose = (ifolder == null && canOpen);
|
2019-02-10 19:22:35 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
try {
|
|
|
|
Log.i(folder.name + " run " + (shouldClose ? "offline" : "online"));
|
2018-10-10 07:26:04 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
if (shouldClose) {
|
|
|
|
// Prevent unnecessary folder connections
|
|
|
|
if (db.operation().getOperationCount(folder.id, null) == 0)
|
|
|
|
return;
|
2018-12-05 10:50:07 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
db.folder().setFolderState(folder.id, "connecting");
|
2020-09-22 06:37:25 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
try {
|
|
|
|
ifolder = iservice.getStore().getFolder(folder.name);
|
|
|
|
} catch (IllegalStateException ex) {
|
|
|
|
if ("Not connected".equals(ex.getMessage()))
|
|
|
|
return; // Store closed
|
|
|
|
else
|
|
|
|
throw ex;
|
|
|
|
}
|
2018-12-05 10:50:07 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
try {
|
|
|
|
ifolder.open(Folder.READ_WRITE);
|
|
|
|
if (ifolder instanceof IMAPFolder)
|
|
|
|
db.folder().setFolderReadOnly(folder.id, ((IMAPFolder) ifolder).getUIDNotSticky());
|
|
|
|
} catch (ReadOnlyFolderException ex) {
|
|
|
|
Log.w(folder.name + " read only");
|
|
|
|
ifolder.open(Folder.READ_ONLY);
|
|
|
|
db.folder().setFolderReadOnly(folder.id, true);
|
|
|
|
}
|
2020-02-11 08:09:31 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
db.folder().setFolderState(folder.id, "connected");
|
|
|
|
db.folder().setFolderError(folder.id, null);
|
2020-02-11 08:09:31 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
int count = MessageHelper.getMessageCount(ifolder);
|
|
|
|
db.folder().setFolderTotal(folder.id, count < 0 ? null : count);
|
2020-01-31 07:45:23 +00:00
|
|
|
|
2020-10-04 14:57:19 +00:00
|
|
|
Log.i(account.name + " folder " + folder.name + " flags=" + ifolder.getPermanentFlags());
|
|
|
|
}
|
|
|
|
|
|
|
|
Core.processOperations(ServiceSynchronize.this,
|
|
|
|
account, folder,
|
|
|
|
partition,
|
|
|
|
iservice.getStore(), ifolder,
|
|
|
|
state, key.getPriority(), sequence);
|
|
|
|
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(folder.name, ex);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Account,
|
2021-05-01 13:26:02 +00:00
|
|
|
folder.name + " process " + Log.formatThrowable(ex, false));
|
2020-10-04 14:57:19 +00:00
|
|
|
db.folder().setFolderError(folder.id, Log.formatThrowable(ex));
|
2020-10-20 12:33:29 +00:00
|
|
|
if (!(ex instanceof FolderNotFoundException))
|
|
|
|
state.error(new OperationCanceledException("Process"));
|
2020-10-04 14:57:19 +00:00
|
|
|
} finally {
|
|
|
|
if (shouldClose) {
|
|
|
|
if (ifolder != null && ifolder.isOpen()) {
|
|
|
|
db.folder().setFolderState(folder.id, "closing");
|
|
|
|
try {
|
|
|
|
ifolder.close(false);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.w(folder.name, ex);
|
2019-03-06 16:36:20 +00:00
|
|
|
}
|
2018-12-02 13:19:54 +00:00
|
|
|
}
|
2020-10-26 12:21:43 +00:00
|
|
|
db.folder().setFolderState(folder.id, null);
|
2018-12-02 13:19:54 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-04 14:57:19 +00:00
|
|
|
} finally {
|
|
|
|
wlOperations.release();
|
2020-02-11 15:11:03 +00:00
|
|
|
}
|
2020-10-04 14:57:19 +00:00
|
|
|
}
|
|
|
|
});
|
2019-03-06 16:36:20 +00:00
|
|
|
}
|
2018-12-05 10:50:07 +00:00
|
|
|
}
|
2020-10-04 14:57:19 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2018-10-17 10:11:24 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
// Keep alive
|
2019-12-28 19:35:41 +00:00
|
|
|
boolean first = true;
|
2019-12-09 21:26:29 +00:00
|
|
|
while (state.isRunning()) {
|
2020-03-31 09:33:13 +00:00
|
|
|
long idleTime = state.getIdleTime();
|
2020-06-12 06:36:27 +00:00
|
|
|
boolean tune_keep_alive = prefs.getBoolean("tune_keep_alive", true);
|
|
|
|
boolean tune = (tune_keep_alive && !first &&
|
2020-03-31 14:41:29 +00:00
|
|
|
!account.keep_alive_ok && account.poll_interval > 9 &&
|
2020-03-31 10:33:33 +00:00
|
|
|
Math.abs(idleTime - account.poll_interval * 60 * 1000L) < 60 * 1000L);
|
2020-06-12 06:36:27 +00:00
|
|
|
if (tune_keep_alive && !first && !account.keep_alive_ok)
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name +
|
|
|
|
" Tune interval=" + account.poll_interval +
|
|
|
|
" idle=" + idleTime + "/" + tune);
|
2019-12-28 19:35:41 +00:00
|
|
|
try {
|
2021-07-30 13:38:16 +00:00
|
|
|
if (!state.isRecoverable()) {
|
|
|
|
Throwable unrecoverable = state.getUnrecoverable();
|
|
|
|
Exception cause =
|
|
|
|
(unrecoverable instanceof Exception
|
|
|
|
? (Exception) unrecoverable
|
|
|
|
: new Exception(unrecoverable));
|
|
|
|
throw new StoreClosedException(iservice.getStore(), "Unrecoverable", cause);
|
|
|
|
}
|
2019-12-28 19:35:41 +00:00
|
|
|
|
|
|
|
// Sends store NOOP
|
2020-12-25 14:51:04 +00:00
|
|
|
if (EmailService.SEPARATE_STORE_CONNECTION) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " checking store" +
|
|
|
|
" memory=" + Log.getFreeMemMb() +
|
|
|
|
" battery=" + Helper.getBatteryLevel(this));
|
2020-12-25 14:51:04 +00:00
|
|
|
if (!iservice.getStore().isConnected())
|
|
|
|
throw new StoreClosedException(iservice.getStore(), "NOOP");
|
|
|
|
}
|
2019-12-28 19:35:41 +00:00
|
|
|
|
2020-10-31 10:11:35 +00:00
|
|
|
if (!getMainLooper().getThread().isAlive()) {
|
2020-01-19 08:09:50 +00:00
|
|
|
Log.e("App died");
|
2020-10-31 10:11:35 +00:00
|
|
|
EntityLog.log(this, account.name + " app died");
|
2020-01-19 08:09:50 +00:00
|
|
|
state.stop();
|
|
|
|
throw new StoreClosedException(iservice.getStore(), "App died");
|
|
|
|
}
|
|
|
|
|
2020-08-14 07:44:56 +00:00
|
|
|
if (sync) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " checking folders");
|
2019-12-28 19:35:41 +00:00
|
|
|
for (EntityFolder folder : mapFolders.keySet())
|
2020-12-29 14:11:13 +00:00
|
|
|
if (folder.selectable && folder.synchronize)
|
2019-12-28 19:35:41 +00:00
|
|
|
if (!folder.poll && capIdle) {
|
|
|
|
// Sends folder NOOP
|
2020-04-22 06:46:18 +00:00
|
|
|
if (!mapFolders.get(folder).isOpen())
|
2020-11-04 12:30:21 +00:00
|
|
|
throw new StoreClosedException(iservice.getStore(), "NOOP " + folder.name);
|
2020-02-25 20:06:17 +00:00
|
|
|
} else {
|
2021-03-05 16:43:05 +00:00
|
|
|
if (folder.poll_count == 0) {
|
2021-07-30 14:23:07 +00:00
|
|
|
EntityLog.log(this, folder.name + " queue sync poll");
|
2021-07-30 19:24:48 +00:00
|
|
|
EntityOperation.poll(this, folder.id);
|
2021-03-05 16:43:05 +00:00
|
|
|
}
|
2020-02-25 20:06:17 +00:00
|
|
|
folder.poll_count = (folder.poll_count + 1) % folder.poll_factor;
|
|
|
|
db.folder().setFolderPollCount(folder.id, folder.poll_count);
|
2021-07-30 14:23:07 +00:00
|
|
|
EntityLog.log(this, folder.name +
|
|
|
|
" poll count=" + folder.poll_count +
|
|
|
|
" factor=" + folder.poll_factor);
|
2020-02-25 20:06:17 +00:00
|
|
|
}
|
2020-08-14 07:44:56 +00:00
|
|
|
}
|
2019-12-28 19:35:41 +00:00
|
|
|
} catch (Throwable ex) {
|
2020-06-12 06:36:27 +00:00
|
|
|
if (tune) {
|
2019-12-28 19:35:41 +00:00
|
|
|
account.keep_alive_failed++;
|
2020-04-01 06:57:27 +00:00
|
|
|
account.keep_alive_succeeded = 0;
|
2019-12-29 16:00:38 +00:00
|
|
|
if (account.keep_alive_failed >= 3) {
|
2019-12-28 19:35:41 +00:00
|
|
|
account.keep_alive_failed = 0;
|
2020-10-21 06:33:28 +00:00
|
|
|
account.poll_interval = account.poll_interval - 2;
|
2019-12-28 19:35:41 +00:00
|
|
|
db.account().setAccountKeepAliveInterval(account.id, account.poll_interval);
|
|
|
|
}
|
2020-04-01 06:57:27 +00:00
|
|
|
db.account().setAccountKeepAliveValues(account.id,
|
|
|
|
account.keep_alive_failed, account.keep_alive_succeeded);
|
2020-10-31 10:11:35 +00:00
|
|
|
EntityLog.log(this, account.name + " keep alive" +
|
2020-04-01 06:57:27 +00:00
|
|
|
" failed=" + account.keep_alive_failed +
|
|
|
|
" succeeded=" + account.keep_alive_succeeded +
|
|
|
|
" interval=" + account.poll_interval +
|
|
|
|
" idle=" + idleTime);
|
2019-12-28 19:35:41 +00:00
|
|
|
}
|
2020-10-28 19:09:38 +00:00
|
|
|
|
2019-12-28 19:35:41 +00:00
|
|
|
throw ex;
|
|
|
|
}
|
|
|
|
|
2020-06-12 06:36:27 +00:00
|
|
|
if (tune) {
|
2020-03-31 09:33:13 +00:00
|
|
|
account.keep_alive_failed = 0;
|
2020-04-01 06:57:27 +00:00
|
|
|
account.keep_alive_succeeded++;
|
|
|
|
db.account().setAccountKeepAliveValues(account.id,
|
|
|
|
account.keep_alive_failed, account.keep_alive_succeeded);
|
|
|
|
if (account.keep_alive_succeeded >= 3) {
|
|
|
|
account.keep_alive_ok = true;
|
|
|
|
db.account().setAccountKeepAliveOk(account.id, true);
|
|
|
|
if (!BuildConfig.PLAY_STORE_RELEASE)
|
2020-07-06 10:29:20 +00:00
|
|
|
Log.w(account.host + " set keep-alive=" + account.poll_interval);
|
2020-10-31 10:11:35 +00:00
|
|
|
EntityLog.log(this, account.name + " keep alive ok");
|
2020-04-01 06:57:27 +00:00
|
|
|
} else
|
2020-10-31 10:11:35 +00:00
|
|
|
EntityLog.log(this, account.name + " keep alive" +
|
2020-04-01 06:57:27 +00:00
|
|
|
" failed=" + account.keep_alive_failed +
|
|
|
|
" succeeded=" + account.keep_alive_succeeded +
|
|
|
|
" interval=" + account.poll_interval +
|
|
|
|
" idle=" + idleTime);
|
2019-12-28 19:35:41 +00:00
|
|
|
}
|
2019-12-09 21:26:29 +00:00
|
|
|
|
|
|
|
// Successfully connected: reset back off time
|
2019-12-11 10:43:32 +00:00
|
|
|
state.setBackoff(CONNECT_BACKOFF_START);
|
2019-12-09 21:26:29 +00:00
|
|
|
|
|
|
|
// Record successful connection
|
|
|
|
account.last_connected = new Date().getTime();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " set last_connected=" + new Date(account.last_connected));
|
2019-12-09 21:26:29 +00:00
|
|
|
db.account().setAccountConnected(account.id, account.last_connected);
|
|
|
|
db.account().setAccountWarning(account.id, capIdle ? null : getString(R.string.title_no_idle));
|
|
|
|
|
2021-07-15 16:36:39 +00:00
|
|
|
NotificationManager nm =
|
|
|
|
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
|
|
nm.cancel("receive:" + account.id, NotificationHelper.NOTIFICATION_TAGGED);
|
|
|
|
nm.cancel("alert:" + account.id, NotificationHelper.NOTIFICATION_TAGGED);
|
2019-12-09 21:26:29 +00:00
|
|
|
|
|
|
|
// Schedule keep alive alarm
|
2020-10-31 10:11:35 +00:00
|
|
|
Intent intent = new Intent(this, ServiceSynchronize.class);
|
2019-12-12 10:10:57 +00:00
|
|
|
intent.setAction("keepalive:" + account.id);
|
|
|
|
PendingIntent pi = PendingIntentCompat.getForegroundService(
|
|
|
|
this, PI_KEEPALIVE, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
|
|
|
|
2019-12-09 21:26:29 +00:00
|
|
|
AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
|
|
|
|
try {
|
|
|
|
long duration = account.poll_interval * 60 * 1000L;
|
|
|
|
long trigger = System.currentTimeMillis() + duration;
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### " + account.name + " keep alive" +
|
|
|
|
" wait=" + account.poll_interval + " until=" + new Date(trigger));
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(ServiceSynchronize.this, am, AlarmManager.RTC_WAKEUP, trigger, pi);
|
2018-10-08 06:18:44 +00:00
|
|
|
|
2018-10-10 07:26:04 +00:00
|
|
|
try {
|
2018-12-02 13:19:54 +00:00
|
|
|
wlAccount.release();
|
2020-09-23 18:31:37 +00:00
|
|
|
state.acquire(2 * duration, false);
|
2019-12-12 06:34:29 +00:00
|
|
|
Log.i("### " + account.name + " keeping alive");
|
2018-10-10 07:26:04 +00:00
|
|
|
} catch (InterruptedException ex) {
|
2018-11-28 18:47:16 +00:00
|
|
|
EntityLog.log(this, account.name + " waited state=" + state);
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2018-12-02 13:19:54 +00:00
|
|
|
wlAccount.acquire();
|
2018-10-10 07:26:04 +00:00
|
|
|
}
|
2019-12-09 21:26:29 +00:00
|
|
|
} finally {
|
2019-12-12 10:10:57 +00:00
|
|
|
am.cancel(pi);
|
2019-06-21 15:58:41 +00:00
|
|
|
}
|
2019-12-28 19:35:41 +00:00
|
|
|
|
|
|
|
first = false;
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
2018-10-08 06:18:44 +00:00
|
|
|
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.i(account.name + " done state=" + state);
|
2018-10-10 07:26:04 +00:00
|
|
|
} catch (Throwable ex) {
|
2020-10-30 07:34:13 +00:00
|
|
|
last_fail = ex;
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.e(account.name, ex);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-05-01 13:26:02 +00:00
|
|
|
account.name + " connect " + Log.formatThrowable(ex, false));
|
2019-12-06 07:50:46 +00:00
|
|
|
db.account().setAccountError(account.id, Log.formatThrowable(ex));
|
2020-07-05 16:46:15 +00:00
|
|
|
|
|
|
|
// Report account connection error
|
|
|
|
if (account.last_connected != null && !ConnectionHelper.airplaneMode(this)) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " last connected: " + new Date(account.last_connected));
|
2020-07-05 16:46:15 +00:00
|
|
|
|
2021-05-01 17:02:39 +00:00
|
|
|
int pollInterval = getPollInterval(this);
|
2020-10-28 19:09:38 +00:00
|
|
|
long now = new Date().getTime();
|
2020-07-05 16:46:15 +00:00
|
|
|
long delayed = now - account.last_connected - account.poll_interval * 60 * 1000L;
|
|
|
|
long maxDelayed = (pollInterval > 0 && !account.poll_exempted
|
|
|
|
? pollInterval * ACCOUNT_ERROR_AFTER_POLL : ACCOUNT_ERROR_AFTER) * 60 * 1000L;
|
2021-01-12 20:38:22 +00:00
|
|
|
if (delayed > maxDelayed &&
|
|
|
|
state.getBackoff() >= CONNECT_BACKOFF_ALARM_START * 60) {
|
2020-07-05 16:46:15 +00:00
|
|
|
Log.i("Reporting sync error after=" + delayed);
|
|
|
|
Throwable warning = new Throwable(
|
|
|
|
getString(R.string.title_no_sync,
|
|
|
|
Helper.getDateTimeInstance(this, DateFormat.SHORT, DateFormat.SHORT)
|
|
|
|
.format(account.last_connected)), ex);
|
|
|
|
try {
|
|
|
|
NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
2021-07-15 16:36:39 +00:00
|
|
|
nm.notify("receive:" + account.id,
|
|
|
|
NotificationHelper.NOTIFICATION_TAGGED,
|
2021-07-31 18:13:58 +00:00
|
|
|
Core.getNotificationError(this, "warning", account, 0, warning)
|
2020-07-05 16:46:15 +00:00
|
|
|
.build());
|
|
|
|
} catch (Throwable ex1) {
|
|
|
|
Log.w(ex1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-08-15 19:34:22 +00:00
|
|
|
} finally {
|
2019-12-09 07:39:51 +00:00
|
|
|
// Update state
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " closing");
|
2019-12-09 07:39:51 +00:00
|
|
|
|
2020-09-22 11:10:46 +00:00
|
|
|
// Stop watching operations
|
|
|
|
Log.i(account.name + " stop watching operations");
|
2020-08-23 15:34:14 +00:00
|
|
|
getMainHandler().post(new Runnable() {
|
2019-03-30 19:26:09 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-10-04 14:57:19 +00:00
|
|
|
try {
|
2020-10-05 06:22:16 +00:00
|
|
|
if (cowner.value != null)
|
|
|
|
cowner.value.destroy();
|
2020-10-04 14:57:19 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2019-03-30 19:26:09 +00:00
|
|
|
}
|
|
|
|
});
|
2018-12-05 09:25:35 +00:00
|
|
|
|
2020-09-22 11:10:46 +00:00
|
|
|
// Stop executing operations
|
|
|
|
Log.i(account.name + " stop executing operations");
|
2020-09-22 12:04:26 +00:00
|
|
|
state.resetBatches();
|
2020-09-23 06:19:28 +00:00
|
|
|
((ThreadPoolExecutor) executor).getQueue().clear();
|
2020-03-04 08:24:24 +00:00
|
|
|
|
2020-09-24 06:12:25 +00:00
|
|
|
// Close store
|
2018-10-10 07:26:04 +00:00
|
|
|
try {
|
2020-09-24 06:20:19 +00:00
|
|
|
db.account().setAccountState(account.id, "closing");
|
2021-07-31 07:25:58 +00:00
|
|
|
for (EntityFolder folder : mapFolders.keySet())
|
|
|
|
if (folder.selectable && folder.synchronize && !folder.poll && mapFolders.get(folder) != null)
|
|
|
|
db.folder().setFolderState(folder.id, "closing");
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " store closing");
|
2019-07-28 19:45:29 +00:00
|
|
|
iservice.close();
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " store closed");
|
2018-11-27 15:36:42 +00:00
|
|
|
} catch (Throwable ex) {
|
2018-12-24 12:27:45 +00:00
|
|
|
Log.w(account.name, ex);
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " closed");
|
2018-10-10 07:26:04 +00:00
|
|
|
db.account().setAccountState(account.id, null);
|
2021-07-31 07:25:58 +00:00
|
|
|
for (EntityFolder folder : mapFolders.keySet())
|
|
|
|
db.folder().setFolderState(folder.id, null);
|
2018-09-08 08:43:13 +00:00
|
|
|
}
|
2018-10-10 08:07:37 +00:00
|
|
|
|
|
|
|
// Stop idlers
|
2018-11-28 18:47:16 +00:00
|
|
|
for (Thread idler : idlers)
|
|
|
|
state.join(idler);
|
2018-12-02 13:19:54 +00:00
|
|
|
idlers.clear();
|
2018-08-15 19:34:22 +00:00
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2019-12-09 07:51:05 +00:00
|
|
|
if (state.isRunning()) {
|
2020-10-28 17:57:51 +00:00
|
|
|
long now = new Date().getTime();
|
2020-10-29 09:45:24 +00:00
|
|
|
|
|
|
|
// Check for fast successive server, connectivity, etc failures
|
2020-11-03 15:49:04 +00:00
|
|
|
long poll_interval = Math.min(account.poll_interval, CONNECT_BACKOFF_ALARM_START);
|
|
|
|
long fail_threshold = poll_interval * 60 * 1000L * FAST_FAIL_THRESHOLD / 100;
|
2020-11-01 08:09:51 +00:00
|
|
|
long was_connected = (account.last_connected == null ? 0 : now - account.last_connected);
|
2021-06-17 05:45:33 +00:00
|
|
|
if (was_connected < fail_threshold) {
|
2020-11-01 08:15:41 +00:00
|
|
|
if (state.getBackoff() == CONNECT_BACKOFF_START) {
|
2020-10-29 09:45:24 +00:00
|
|
|
fast_fails++;
|
|
|
|
if (fast_fails == 1)
|
|
|
|
first_fail = now;
|
2021-08-06 06:21:06 +00:00
|
|
|
else if (fast_fails >= FAST_FAIL_COUNT) {
|
2020-10-29 09:45:24 +00:00
|
|
|
long avg_fail = (now - first_fail) / fast_fails;
|
|
|
|
if (avg_fail < fail_threshold) {
|
|
|
|
long missing = (fail_threshold - avg_fail) * fast_fails;
|
|
|
|
int compensate = (int) (missing / (CONNECT_BACKOFF_ALARM_START * 60 * 1000L));
|
|
|
|
if (compensate > 0) {
|
2021-08-05 20:02:45 +00:00
|
|
|
if (was_connected != 0 && was_connected < CONNECT_BACKOFF_GRACE)
|
2020-10-30 08:22:14 +00:00
|
|
|
compensate = 1;
|
|
|
|
|
2020-10-29 09:45:24 +00:00
|
|
|
int backoff = compensate * CONNECT_BACKOFF_ALARM_START;
|
|
|
|
if (backoff > CONNECT_BACKOFF_ALARM_MAX)
|
|
|
|
backoff = CONNECT_BACKOFF_ALARM_MAX;
|
2020-10-30 08:22:14 +00:00
|
|
|
|
2020-10-29 09:45:24 +00:00
|
|
|
String msg = "Fast" +
|
|
|
|
" fails=" + fast_fails +
|
2020-11-01 08:09:51 +00:00
|
|
|
" was=" + (was_connected / 1000L) +
|
2020-10-29 15:21:02 +00:00
|
|
|
" first=" + ((now - first_fail) / 1000L) +
|
2020-11-03 15:49:04 +00:00
|
|
|
" poll=" + poll_interval +
|
2020-10-29 09:45:24 +00:00
|
|
|
" avg=" + (avg_fail / 1000L) + "/" + (fail_threshold / 1000L) +
|
|
|
|
" missing=" + (missing / 1000L) +
|
|
|
|
" compensate=" + compensate +
|
|
|
|
" backoff=" + backoff +
|
2020-10-30 07:34:13 +00:00
|
|
|
" host=" + account.host +
|
|
|
|
" ex=" + Log.formatThrowable(last_fail, false);
|
2021-01-20 15:22:56 +00:00
|
|
|
if (compensate > 2)
|
2020-10-31 16:53:37 +00:00
|
|
|
Log.e(msg);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account, msg);
|
2020-10-30 08:22:14 +00:00
|
|
|
|
2020-10-29 09:45:24 +00:00
|
|
|
state.setBackoff(backoff * 60);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fast_fails = 0;
|
|
|
|
first_fail = 0;
|
|
|
|
}
|
|
|
|
|
2019-12-11 10:43:32 +00:00
|
|
|
int backoff = state.getBackoff();
|
2020-10-31 09:33:10 +00:00
|
|
|
int recently = (lastLost + LOST_RECENTLY < now ? 1 : 2);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " backoff=" + backoff + " recently=" + recently + "x");
|
2020-10-28 17:57:51 +00:00
|
|
|
|
2020-11-20 09:06:35 +00:00
|
|
|
if (backoff < CONNECT_BACKOFF_MAX)
|
|
|
|
state.setBackoff(backoff * 2);
|
|
|
|
else if (backoff == CONNECT_BACKOFF_MAX)
|
2021-08-07 07:03:55 +00:00
|
|
|
if (AlarmManagerCompatEx.hasExactAlarms(this))
|
|
|
|
state.setBackoff(CONNECT_BACKOFF_INTERMEDIATE * 60);
|
|
|
|
else
|
|
|
|
state.setBackoff(CONNECT_BACKOFF_ALARM_START * 60);
|
|
|
|
else if (backoff == CONNECT_BACKOFF_INTERMEDIATE * 60)
|
2021-06-17 05:45:33 +00:00
|
|
|
state.setBackoff(CONNECT_BACKOFF_ALARM_START * 60);
|
2021-08-06 05:39:11 +00:00
|
|
|
else if (backoff < CONNECT_BACKOFF_ALARM_MAX * 60) {
|
|
|
|
int b = backoff * 2;
|
|
|
|
if (b > CONNECT_BACKOFF_ALARM_MAX * 60)
|
|
|
|
b = CONNECT_BACKOFF_ALARM_MAX * 60;
|
|
|
|
state.setBackoff(b);
|
|
|
|
}
|
2020-11-20 09:06:35 +00:00
|
|
|
|
2020-10-31 09:33:10 +00:00
|
|
|
if (backoff <= CONNECT_BACKOFF_MAX) {
|
2020-10-28 17:57:51 +00:00
|
|
|
// Short back-off period, keep device awake
|
2019-12-09 07:51:05 +00:00
|
|
|
try {
|
2020-11-20 09:06:35 +00:00
|
|
|
long interval = backoff * 1000L * recently;
|
|
|
|
db.account().setAccountBackoff(account.id, System.currentTimeMillis() + interval);
|
|
|
|
state.acquire(interval, true);
|
2019-12-09 07:51:05 +00:00
|
|
|
} catch (InterruptedException ex) {
|
2020-10-28 17:57:51 +00:00
|
|
|
Log.w(account.name + " backoff " + ex.toString());
|
2020-10-29 19:03:09 +00:00
|
|
|
} finally {
|
|
|
|
db.account().setAccountBackoff(account.id, null);
|
2019-12-09 07:51:05 +00:00
|
|
|
}
|
|
|
|
} else {
|
2020-10-28 17:57:51 +00:00
|
|
|
// Cancel transient sync operations
|
2020-12-26 15:41:34 +00:00
|
|
|
if (account.isTransient(this)) {
|
2020-10-28 17:57:51 +00:00
|
|
|
List<EntityOperation> syncs = db.operation().getOperations(account.id, EntityOperation.SYNC);
|
|
|
|
if (syncs != null) {
|
|
|
|
for (EntityOperation op : syncs) {
|
|
|
|
db.folder().setFolderSyncState(op.folder, null);
|
|
|
|
db.operation().deleteOperation(op.id);
|
2020-03-11 08:11:35 +00:00
|
|
|
}
|
2020-10-28 17:57:51 +00:00
|
|
|
Log.i(account.name + " cancelled syncs=" + syncs.size());
|
2020-03-11 08:11:35 +00:00
|
|
|
}
|
2020-10-28 17:57:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Long back-off period, let device sleep
|
2020-10-31 10:11:35 +00:00
|
|
|
Intent intent = new Intent(this, ServiceSynchronize.class);
|
2020-10-28 17:57:51 +00:00
|
|
|
intent.setAction("backoff:" + account.id);
|
|
|
|
PendingIntent pi = PendingIntentCompat.getForegroundService(
|
|
|
|
this, PI_BACKOFF, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
2019-12-12 10:10:57 +00:00
|
|
|
|
2020-10-28 17:57:51 +00:00
|
|
|
AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
|
|
|
|
try {
|
|
|
|
long trigger = System.currentTimeMillis() + backoff * 1000L;
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### " + account.name + " backoff until=" + new Date(trigger));
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(ServiceSynchronize.this, am, AlarmManager.RTC_WAKEUP, trigger, pi);
|
2018-11-09 08:54:24 +00:00
|
|
|
|
2019-12-09 07:51:05 +00:00
|
|
|
try {
|
2020-10-29 19:03:09 +00:00
|
|
|
db.account().setAccountBackoff(account.id, trigger);
|
2020-10-28 17:57:51 +00:00
|
|
|
wlAccount.release();
|
|
|
|
state.acquire(2 * backoff * 1000L, true);
|
|
|
|
Log.i("### " + account.name + " backoff done");
|
|
|
|
} catch (InterruptedException ex) {
|
|
|
|
Log.w(account.name + " backoff " + ex.toString());
|
2018-11-08 17:16:32 +00:00
|
|
|
} finally {
|
2020-10-28 17:57:51 +00:00
|
|
|
wlAccount.acquire();
|
2020-10-29 19:03:09 +00:00
|
|
|
db.account().setAccountBackoff(account.id, null);
|
2019-12-09 07:51:05 +00:00
|
|
|
}
|
2020-10-28 17:57:51 +00:00
|
|
|
} finally {
|
|
|
|
am.cancel(pi);
|
2018-11-08 17:16:32 +00:00
|
|
|
}
|
2020-04-24 07:49:17 +00:00
|
|
|
}
|
2019-12-09 07:51:05 +00:00
|
|
|
}
|
2020-03-08 10:08:28 +00:00
|
|
|
|
2021-04-05 06:23:00 +00:00
|
|
|
accountThread = db.account().getAccountThread(account.id);
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
2020-03-08 10:08:28 +00:00
|
|
|
|
2021-04-05 10:19:44 +00:00
|
|
|
if (!currentThread.equals(accountThread) && accountThread != null)
|
2021-04-18 06:20:54 +00:00
|
|
|
Log.w(account.name + " orphan thread id=" + currentThread + "/" + accountThread);
|
2018-10-10 07:26:04 +00:00
|
|
|
} finally {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " stopped");
|
2018-12-02 13:19:54 +00:00
|
|
|
wlAccount.release();
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-28 09:31:19 +00:00
|
|
|
private void updateQuota(Context context, IMAPStore istore, EntityAccount account) {
|
2020-12-29 17:46:17 +00:00
|
|
|
DB db = DB.getInstance(this);
|
|
|
|
try {
|
|
|
|
if (istore.hasCapability("QUOTA")) {
|
2021-06-28 09:31:19 +00:00
|
|
|
// https://datatracker.ietf.org/doc/html/rfc2087
|
2020-12-29 17:46:17 +00:00
|
|
|
Quota[] quotas = istore.getQuota("INBOX");
|
|
|
|
if (quotas != null) {
|
2021-06-28 09:31:19 +00:00
|
|
|
Long usage = null;
|
|
|
|
Long limit = null;
|
2020-12-29 17:46:17 +00:00
|
|
|
for (Quota quota : quotas)
|
|
|
|
if (quota.resources != null)
|
|
|
|
for (Quota.Resource resource : quota.resources) {
|
2021-06-28 09:31:19 +00:00
|
|
|
EntityLog.log(context, "Quota " + resource.name + " " + resource.usage + "/" + resource.limit);
|
2021-06-29 06:13:10 +00:00
|
|
|
// (STORAGE nnnnn 9999999999999999)
|
2020-12-29 17:46:17 +00:00
|
|
|
if ("STORAGE".equalsIgnoreCase(resource.name)) {
|
2021-06-29 06:13:10 +00:00
|
|
|
if (resource.usage * 1024 >= 0)
|
2021-06-28 09:31:19 +00:00
|
|
|
usage = (usage == null ? 0L : usage) + resource.usage * 1024;
|
2021-06-29 06:13:10 +00:00
|
|
|
if (resource.limit * 1024 > 0)
|
2021-06-28 09:31:19 +00:00
|
|
|
limit = Math.max(limit == null ? 0L : limit, resource.limit * 1024);
|
2020-12-29 17:46:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
db.account().setAccountQuota(account.id, usage, limit);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
db.account().setAccountQuota(account.id, null, null);
|
|
|
|
} catch (MessagingException ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
db.account().setAccountQuota(account.id, null, null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-26 17:56:34 +00:00
|
|
|
private void optimizeAccount(EntityAccount account, String reason) {
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
|
2020-07-09 06:53:16 +00:00
|
|
|
boolean auto_optimize = prefs.getBoolean("auto_optimize", false);
|
2020-03-10 07:44:47 +00:00
|
|
|
if (!auto_optimize)
|
|
|
|
return;
|
|
|
|
|
2020-10-26 17:56:34 +00:00
|
|
|
DB db = DB.getInstance(this);
|
2020-03-10 07:44:47 +00:00
|
|
|
|
2021-05-01 17:02:39 +00:00
|
|
|
int pollInterval = getPollInterval(this);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
account.name + " auto optimize" +
|
|
|
|
" reason=" + reason +
|
|
|
|
" poll interval=" + pollInterval);
|
2020-03-10 07:44:47 +00:00
|
|
|
if (pollInterval == 0) {
|
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
for (EntityAccount a : db.account().getAccounts())
|
|
|
|
db.account().setAccountPollExempted(a.id, !a.id.equals(account.id));
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
2020-10-25 17:21:20 +00:00
|
|
|
prefs.edit().putInt("poll_interval", OPTIMIZE_POLL_INTERVAL).apply();
|
2020-03-30 16:14:02 +00:00
|
|
|
} else if (pollInterval <= 60 && account.poll_exempted) {
|
2020-03-10 07:44:47 +00:00
|
|
|
db.account().setAccountPollExempted(account.id, false);
|
2021-05-11 06:24:18 +00:00
|
|
|
eval(this, "Optimize=" + reason);
|
2020-03-10 07:44:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-17 16:25:38 +00:00
|
|
|
private final ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
|
2018-11-27 15:36:42 +00:00
|
|
|
@Override
|
2019-12-07 14:14:35 +00:00
|
|
|
public void onAvailable(@NonNull Network network) {
|
2021-03-17 11:15:25 +00:00
|
|
|
// Android O+: this will always immediately be followed by a call to onCapabilitiesChanged/onLinkPropertiesChanged
|
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
|
|
|
|
updateNetworkState(network, "available");
|
2018-11-27 15:36:42 +00:00
|
|
|
}
|
|
|
|
|
2018-08-02 13:33:06 +00:00
|
|
|
@Override
|
2020-07-15 18:41:58 +00:00
|
|
|
public void onCapabilitiesChanged(@NonNull Network network, @NonNull NetworkCapabilities caps) {
|
2020-10-28 10:44:15 +00:00
|
|
|
updateNetworkState(network, "capabilities");
|
2018-08-15 07:40:18 +00:00
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
|
2020-07-14 19:12:35 +00:00
|
|
|
@Override
|
2020-07-15 18:41:58 +00:00
|
|
|
public void onLinkPropertiesChanged(@NonNull Network network, @NonNull LinkProperties props) {
|
2020-10-28 10:44:15 +00:00
|
|
|
updateNetworkState(network, "properties");
|
2020-07-14 19:12:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-17 11:16:00 +00:00
|
|
|
@Override
|
|
|
|
public void onBlockedStatusChanged(@NonNull Network network, boolean blocked) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Account,
|
2021-08-15 18:32:34 +00:00
|
|
|
"Network " + network + " blocked=" + blocked);
|
2021-03-17 11:16:00 +00:00
|
|
|
}
|
|
|
|
|
2018-08-15 07:40:18 +00:00
|
|
|
@Override
|
2019-12-07 14:14:35 +00:00
|
|
|
public void onLost(@NonNull Network network) {
|
2020-10-28 10:44:15 +00:00
|
|
|
updateNetworkState(network, "lost");
|
2019-07-29 10:01:13 +00:00
|
|
|
}
|
2019-03-06 10:18:57 +00:00
|
|
|
};
|
2018-08-15 07:40:18 +00:00
|
|
|
|
2021-01-17 16:25:38 +00:00
|
|
|
private final BroadcastReceiver connectionChangedReceiver = new BroadcastReceiver() {
|
2019-09-30 18:44:22 +00:00
|
|
|
@Override
|
|
|
|
public void onReceive(Context context, Intent intent) {
|
2020-01-15 09:59:48 +00:00
|
|
|
Log.i("Received intent=" + intent +
|
2019-10-01 07:20:05 +00:00
|
|
|
" " + TextUtils.join(" ", Log.getExtras(intent.getExtras())));
|
2019-10-04 15:17:42 +00:00
|
|
|
|
|
|
|
if (Intent.ACTION_AIRPLANE_MODE_CHANGED.equals(intent.getAction())) {
|
|
|
|
boolean on = intent.getBooleanExtra("state", false);
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(context, EntityLog.Type.Network,
|
2021-08-15 18:32:34 +00:00
|
|
|
"Airplane mode on=" + on);
|
2019-10-04 15:17:42 +00:00
|
|
|
if (!on)
|
2019-12-12 08:19:30 +00:00
|
|
|
lastLost = 0;
|
2019-10-04 15:17:42 +00:00
|
|
|
}
|
|
|
|
|
2021-01-16 18:21:31 +00:00
|
|
|
updateNetworkState(null, "connectivity");
|
2019-09-30 18:44:22 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2021-01-17 16:26:21 +00:00
|
|
|
private final BroadcastReceiver idleModeChangedReceiver = new BroadcastReceiver() {
|
|
|
|
@Override
|
|
|
|
@RequiresApi(api = Build.VERSION_CODES.M)
|
|
|
|
public void onReceive(Context context, Intent intent) {
|
|
|
|
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
|
|
|
|
EntityLog.log(context, "Doze mode=" + pm.isDeviceIdleMode() +
|
|
|
|
" ignoring=" + pm.isIgnoringBatteryOptimizations(context.getPackageName()));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
private final BroadcastReceiver dataSaverChanged = new BroadcastReceiver() {
|
|
|
|
@Override
|
|
|
|
@RequiresApi(api = Build.VERSION_CODES.N)
|
|
|
|
public void onReceive(Context context, Intent intent) {
|
|
|
|
Log.i("Received intent=" + intent +
|
|
|
|
" " + TextUtils.join(" ", Log.getExtras(intent.getExtras())));
|
|
|
|
|
|
|
|
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
Integer status = (cm == null ? null : cm.getRestrictBackgroundStatus());
|
|
|
|
EntityLog.log(context, "Data saver=" + status);
|
|
|
|
|
|
|
|
updateNetworkState(null, "datasaver");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2021-01-16 18:21:31 +00:00
|
|
|
private void updateNetworkState(final Network network, final String reason) {
|
|
|
|
getMainHandler().post(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
Network active = ConnectionHelper.getActiveNetwork(ServiceSynchronize.this);
|
2020-10-27 19:49:20 +00:00
|
|
|
|
2021-01-16 18:21:31 +00:00
|
|
|
if (active != null && !active.equals(lastActive)) {
|
|
|
|
if (ConnectionHelper.isConnected(ServiceSynchronize.this, active)) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Network,
|
2021-01-16 18:21:31 +00:00
|
|
|
reason + ": new active network=" + active + "/" + lastActive);
|
|
|
|
lastActive = active;
|
|
|
|
}
|
|
|
|
} else if (lastActive != null) {
|
|
|
|
if (!ConnectionHelper.isConnected(ServiceSynchronize.this, lastActive)) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Network,
|
2021-01-16 18:21:31 +00:00
|
|
|
reason + ": lost active network=" + lastActive);
|
|
|
|
lastActive = null;
|
|
|
|
lastLost = new Date().getTime();
|
|
|
|
}
|
|
|
|
}
|
2020-09-24 09:14:27 +00:00
|
|
|
|
2021-01-16 18:21:31 +00:00
|
|
|
if (network == null || Objects.equals(network, active)) {
|
|
|
|
ConnectionHelper.NetworkState ns = ConnectionHelper.getNetworkState(ServiceSynchronize.this);
|
|
|
|
if (!Objects.equals(lastNetworkState, ns)) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Network,
|
2021-01-16 18:21:31 +00:00
|
|
|
reason + ": updating state network=" + active +
|
|
|
|
" info=" + ConnectionHelper.getNetworkInfo(ServiceSynchronize.this, active) + " " + ns);
|
|
|
|
lastNetworkState = ns;
|
|
|
|
liveNetworkState.postValue(ns);
|
|
|
|
}
|
|
|
|
}
|
2020-10-28 10:44:15 +00:00
|
|
|
|
2021-01-16 18:21:31 +00:00
|
|
|
boolean isSuitable = (lastNetworkState != null && lastNetworkState.isSuitable());
|
|
|
|
if (lastSuitable == null || lastSuitable != isSuitable) {
|
|
|
|
lastSuitable = isSuitable;
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Network,
|
2021-08-15 18:32:34 +00:00
|
|
|
reason + ": updated suitable=" + lastSuitable);
|
2021-01-16 18:21:31 +00:00
|
|
|
|
|
|
|
if (!isBackgroundService(ServiceSynchronize.this))
|
|
|
|
try {
|
2021-07-15 16:36:39 +00:00
|
|
|
NotificationManager nm =
|
|
|
|
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
|
|
nm.notify(NotificationHelper.NOTIFICATION_SYNCHRONIZE,
|
|
|
|
getNotificationService(lastAccounts, lastOperations).build());
|
2021-01-16 18:21:31 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.w(ex);
|
|
|
|
}
|
|
|
|
}
|
2020-10-27 20:41:22 +00:00
|
|
|
} catch (Throwable ex) {
|
2021-01-16 18:21:31 +00:00
|
|
|
Log.e(ex);
|
2020-10-27 20:41:22 +00:00
|
|
|
}
|
2021-01-16 18:21:31 +00:00
|
|
|
}
|
|
|
|
});
|
2020-07-17 06:06:25 +00:00
|
|
|
}
|
|
|
|
|
2019-12-12 07:56:57 +00:00
|
|
|
private class MediatorState extends MediatorLiveData<List<TupleAccountNetworkState>> {
|
2020-12-31 13:12:21 +00:00
|
|
|
private boolean running = true;
|
2021-03-16 07:42:32 +00:00
|
|
|
private Bundle lastCommand = null;
|
2019-12-12 07:56:57 +00:00
|
|
|
private ConnectionHelper.NetworkState lastNetworkState = null;
|
|
|
|
private List<TupleAccountState> lastAccountStates = null;
|
|
|
|
|
|
|
|
private void post(Bundle command) {
|
2021-08-16 08:22:26 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"### command " + TextUtils.join(" ", Log.getExtras(command)));
|
2021-01-21 14:41:27 +00:00
|
|
|
|
2021-03-16 07:54:59 +00:00
|
|
|
if (command.getBoolean("sync") || command.getBoolean("force"))
|
2021-01-21 14:41:27 +00:00
|
|
|
lastNetworkState = ConnectionHelper.getNetworkState(ServiceSynchronize.this);
|
|
|
|
|
2019-12-12 07:56:57 +00:00
|
|
|
post(command, lastNetworkState, lastAccountStates);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void post(ConnectionHelper.NetworkState networkState) {
|
|
|
|
lastNetworkState = networkState;
|
2021-03-16 07:42:32 +00:00
|
|
|
post(lastCommand, lastNetworkState, lastAccountStates);
|
2019-12-12 07:56:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private void post(List<TupleAccountState> accountStates) {
|
|
|
|
lastAccountStates = accountStates;
|
2021-03-16 07:42:32 +00:00
|
|
|
post(lastCommand, lastNetworkState, lastAccountStates);
|
2019-12-12 07:56:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private void postDestroy() {
|
|
|
|
if (running) {
|
|
|
|
running = false;
|
|
|
|
postValue(null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void post(Bundle command, ConnectionHelper.NetworkState networkState, List<TupleAccountState> accountStates) {
|
|
|
|
if (!running) {
|
|
|
|
Log.i("### not running");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-06-16 08:51:47 +00:00
|
|
|
if (networkState == null)
|
|
|
|
networkState = ConnectionHelper.getNetworkState(ServiceSynchronize.this);
|
|
|
|
|
2020-12-31 11:10:45 +00:00
|
|
|
if (accountStates == null) {
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(ServiceSynchronize.this, EntityLog.Type.Scheduling, "### no accounts");
|
2021-03-16 07:42:32 +00:00
|
|
|
lastCommand = command;
|
2019-12-12 07:56:57 +00:00
|
|
|
return;
|
2020-12-31 11:10:45 +00:00
|
|
|
}
|
2019-12-12 07:56:57 +00:00
|
|
|
|
2021-03-16 07:42:32 +00:00
|
|
|
lastCommand = null;
|
|
|
|
|
2019-12-12 07:56:57 +00:00
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ServiceSynchronize.this);
|
|
|
|
boolean enabled = prefs.getBoolean("enabled", true);
|
2021-05-01 17:02:39 +00:00
|
|
|
int pollInterval = getPollInterval(ServiceSynchronize.this);
|
2019-12-12 07:56:57 +00:00
|
|
|
|
|
|
|
long[] schedule = getSchedule(ServiceSynchronize.this);
|
|
|
|
long now = new Date().getTime();
|
2020-03-19 20:36:56 +00:00
|
|
|
boolean scheduled = (schedule == null || (now >= schedule[0] && now < schedule[1]));
|
2019-12-12 07:56:57 +00:00
|
|
|
|
|
|
|
if (command == null) {
|
|
|
|
command = new Bundle();
|
|
|
|
command.putString("name", "eval");
|
|
|
|
}
|
|
|
|
|
|
|
|
List<TupleAccountNetworkState> result = new ArrayList<>();
|
|
|
|
for (TupleAccountState accountState : accountStates)
|
|
|
|
result.add(new TupleAccountNetworkState(
|
2020-01-12 17:48:26 +00:00
|
|
|
enabled && (pollInterval == 0 || accountState.poll_exempted) && scheduled,
|
2019-12-12 07:56:57 +00:00
|
|
|
command,
|
|
|
|
networkState,
|
|
|
|
accountState));
|
|
|
|
|
|
|
|
postValue(result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-06 10:18:57 +00:00
|
|
|
static void boot(final Context context) {
|
2020-12-31 11:29:58 +00:00
|
|
|
executor.submit(new Runnable() {
|
2019-08-01 07:08:28 +00:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
2020-12-31 11:29:58 +00:00
|
|
|
EntityLog.log(context, "Boot sync service");
|
|
|
|
|
2019-08-01 07:08:28 +00:00
|
|
|
DB db = DB.getInstance(context);
|
2020-04-05 11:54:38 +00:00
|
|
|
try {
|
|
|
|
db.beginTransaction();
|
|
|
|
|
|
|
|
// Restore notifications
|
|
|
|
db.message().clearNotifyingMessages();
|
|
|
|
|
|
|
|
// Restore snooze timers
|
|
|
|
for (EntityMessage message : db.message().getSnoozed(null))
|
|
|
|
EntityMessage.snooze(context, message.id, message.ui_snoozed);
|
|
|
|
|
|
|
|
db.setTransactionSuccessful();
|
|
|
|
} finally {
|
|
|
|
db.endTransaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Restore schedule
|
2020-08-30 07:34:51 +00:00
|
|
|
schedule(context, false);
|
2020-04-05 11:54:38 +00:00
|
|
|
|
|
|
|
// Init service
|
2020-12-31 13:12:21 +00:00
|
|
|
eval(context, "boot");
|
2019-08-01 07:08:28 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
2018-11-29 07:35:34 +00:00
|
|
|
}
|
2019-08-01 07:08:28 +00:00
|
|
|
}
|
2020-12-31 11:29:58 +00:00
|
|
|
});
|
2019-08-01 07:08:28 +00:00
|
|
|
}
|
|
|
|
|
2021-06-16 09:48:16 +00:00
|
|
|
private static void schedule(Context context, boolean polled) {
|
2020-01-10 11:08:14 +00:00
|
|
|
Intent intent = new Intent(context, ServiceSynchronize.class);
|
|
|
|
intent.setAction("alarm");
|
|
|
|
PendingIntent pi = PendingIntentCompat.getForegroundService(
|
|
|
|
context, PI_ALARM, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
2019-02-28 07:55:08 +00:00
|
|
|
|
|
|
|
AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
|
2020-01-10 11:08:14 +00:00
|
|
|
am.cancel(pi);
|
2019-02-28 07:55:08 +00:00
|
|
|
|
2021-06-16 09:48:16 +00:00
|
|
|
boolean scheduled;
|
2020-08-30 07:34:51 +00:00
|
|
|
Long at = null;
|
2019-12-07 14:14:35 +00:00
|
|
|
long[] schedule = getSchedule(context);
|
|
|
|
if (schedule == null)
|
2021-06-16 09:48:16 +00:00
|
|
|
scheduled = true;
|
2020-01-10 11:12:14 +00:00
|
|
|
else {
|
|
|
|
long now = new Date().getTime();
|
|
|
|
long next = (now < schedule[0] ? schedule[0] : schedule[1]);
|
2021-06-16 09:48:16 +00:00
|
|
|
scheduled = (now >= schedule[0] && now < schedule[1]);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2020-01-10 11:12:14 +00:00
|
|
|
Log.i("Schedule now=" + new Date(now));
|
|
|
|
Log.i("Schedule start=" + new Date(schedule[0]));
|
|
|
|
Log.i("Schedule end=" + new Date(schedule[1]));
|
|
|
|
Log.i("Schedule next=" + new Date(next));
|
2021-06-16 09:48:16 +00:00
|
|
|
Log.i("Schedule scheduled=" + scheduled);
|
2019-12-07 14:14:35 +00:00
|
|
|
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(context, am, AlarmManager.RTC_WAKEUP, next, pi);
|
2020-08-29 09:26:47 +00:00
|
|
|
|
2021-06-16 09:48:16 +00:00
|
|
|
if (scheduled && polled) {
|
2020-08-30 07:34:51 +00:00
|
|
|
at = now + 30 * 1000L;
|
|
|
|
Log.i("Sync at schedule start=" + new Date(at));
|
2020-08-29 09:26:47 +00:00
|
|
|
}
|
2020-01-10 11:12:14 +00:00
|
|
|
}
|
2020-01-10 11:08:14 +00:00
|
|
|
|
2021-06-16 09:48:16 +00:00
|
|
|
schedule(context, scheduled, polled, at);
|
2021-03-29 13:22:49 +00:00
|
|
|
}
|
|
|
|
|
2021-06-16 09:48:16 +00:00
|
|
|
private static void schedule(Context context, boolean scheduled, boolean polled, Long at) {
|
2021-03-29 13:22:49 +00:00
|
|
|
Intent intent = new Intent(context, ServiceSynchronize.class);
|
|
|
|
intent.setAction("poll");
|
|
|
|
PendingIntent piSync = PendingIntentCompat.getForegroundService(
|
|
|
|
context, PI_POLL, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
|
|
|
|
|
|
|
AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
|
|
|
|
am.cancel(piSync);
|
|
|
|
|
|
|
|
if (at == null) {
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
boolean enabled = prefs.getBoolean("enabled", true);
|
2021-05-01 17:02:39 +00:00
|
|
|
int pollInterval = getPollInterval(context);
|
2021-06-16 09:48:16 +00:00
|
|
|
if (scheduled && enabled && pollInterval > 0) {
|
2021-03-29 13:22:49 +00:00
|
|
|
long now = new Date().getTime();
|
|
|
|
long interval = pollInterval * 60 * 1000L;
|
2021-06-16 10:53:04 +00:00
|
|
|
long next = now - now % interval + 30 * 1000L;
|
|
|
|
if (polled || next < now)
|
|
|
|
next += interval;
|
2021-06-16 09:48:16 +00:00
|
|
|
if (polled && next < now + interval / 5)
|
2021-03-29 13:22:49 +00:00
|
|
|
next += interval;
|
|
|
|
|
2021-08-16 07:36:23 +00:00
|
|
|
EntityLog.log(context, EntityLog.Type.Scheduling,
|
2021-08-15 18:32:34 +00:00
|
|
|
"Poll next=" + new Date(next) + " polled=" + polled);
|
2021-03-29 13:22:49 +00:00
|
|
|
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(context, am, AlarmManager.RTC_WAKEUP, next, piSync);
|
2021-03-29 13:22:49 +00:00
|
|
|
}
|
|
|
|
} else
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(context, am, AlarmManager.RTC_WAKEUP, at, piSync);
|
2019-12-07 14:14:35 +00:00
|
|
|
}
|
|
|
|
|
2021-05-01 17:02:39 +00:00
|
|
|
static int getPollInterval(Context context) {
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
int poll_interval = prefs.getInt("poll_interval", 0); // minutes
|
|
|
|
//if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
|
|
|
|
// Boolean ignoring = Helper.isIgnoringOptimizations(context);
|
|
|
|
// if (ignoring != null && !ignoring)
|
|
|
|
// poll_interval = 15;
|
|
|
|
//}
|
|
|
|
return poll_interval;
|
|
|
|
}
|
|
|
|
|
2020-01-14 08:02:37 +00:00
|
|
|
static long[] getSchedule(Context context) {
|
2019-02-28 07:55:08 +00:00
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
2020-03-19 20:36:56 +00:00
|
|
|
boolean enabled = prefs.getBoolean("enabled", true);
|
|
|
|
boolean schedule = prefs.getBoolean("schedule", false);
|
|
|
|
|
|
|
|
if (!enabled || !schedule)
|
2019-12-23 13:08:04 +00:00
|
|
|
return null;
|
|
|
|
|
|
|
|
if (!ActivityBilling.isPro(context))
|
2019-12-07 14:14:35 +00:00
|
|
|
return null;
|
2019-02-28 07:55:08 +00:00
|
|
|
|
|
|
|
int minuteStart = prefs.getInt("schedule_start", 0);
|
|
|
|
int minuteEnd = prefs.getInt("schedule_end", 0);
|
|
|
|
|
|
|
|
Calendar calStart = Calendar.getInstance();
|
|
|
|
calStart.set(Calendar.HOUR_OF_DAY, minuteStart / 60);
|
|
|
|
calStart.set(Calendar.MINUTE, minuteStart % 60);
|
|
|
|
calStart.set(Calendar.SECOND, 0);
|
|
|
|
calStart.set(Calendar.MILLISECOND, 0);
|
2019-12-23 13:08:04 +00:00
|
|
|
calStart.add(Calendar.DATE, -1);
|
2019-02-28 07:55:08 +00:00
|
|
|
|
|
|
|
Calendar calEnd = Calendar.getInstance();
|
|
|
|
calEnd.set(Calendar.HOUR_OF_DAY, minuteEnd / 60);
|
|
|
|
calEnd.set(Calendar.MINUTE, minuteEnd % 60);
|
|
|
|
calEnd.set(Calendar.SECOND, 0);
|
|
|
|
calEnd.set(Calendar.MILLISECOND, 0);
|
2019-12-23 13:08:04 +00:00
|
|
|
if (minuteEnd > minuteStart)
|
|
|
|
calEnd.add(Calendar.DATE, -1);
|
2019-02-28 07:55:08 +00:00
|
|
|
|
|
|
|
long now = new Date().getTime();
|
2019-12-23 13:08:04 +00:00
|
|
|
|
|
|
|
boolean found = false;
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
|
|
int sdow = calStart.get(Calendar.DAY_OF_WEEK) - 1;
|
|
|
|
int edow = calEnd.get(Calendar.DAY_OF_WEEK) - 1;
|
|
|
|
boolean son = prefs.getBoolean("schedule_day" + sdow, true);
|
|
|
|
boolean eon = prefs.getBoolean("schedule_day" + edow, true);
|
|
|
|
|
|
|
|
if (BuildConfig.DEBUG)
|
|
|
|
Log.i("@@@ eval dow=" + sdow + "/" + edow +
|
|
|
|
" on=" + son + "/" + eon +
|
|
|
|
" start=" + new Date(calStart.getTimeInMillis()) +
|
|
|
|
" end=" + new Date(calEnd.getTimeInMillis()));
|
|
|
|
|
|
|
|
if ((son || eon) &&
|
|
|
|
now < calEnd.getTimeInMillis() &&
|
|
|
|
(i > 0 || (now >= calStart.getTimeInMillis() && eon))) {
|
|
|
|
found = true;
|
|
|
|
|
|
|
|
if (!son) {
|
|
|
|
calStart.set(Calendar.HOUR_OF_DAY, 0);
|
|
|
|
calStart.set(Calendar.MINUTE, 0);
|
|
|
|
calStart.add(Calendar.DATE, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!eon) {
|
|
|
|
calEnd.set(Calendar.HOUR_OF_DAY, 0);
|
|
|
|
calEnd.set(Calendar.MINUTE, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
calStart.add(Calendar.DATE, 1);
|
|
|
|
calEnd.add(Calendar.DATE, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
if (BuildConfig.DEBUG)
|
|
|
|
Log.i("@@@ not found");
|
|
|
|
return null;
|
2019-02-28 07:55:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
long start = calStart.getTimeInMillis();
|
|
|
|
long end = calEnd.getTimeInMillis();
|
2019-12-23 13:08:04 +00:00
|
|
|
|
|
|
|
if (BuildConfig.DEBUG) {
|
|
|
|
Log.i("@@@ start=" + new Date(start));
|
|
|
|
Log.i("@@@ end=" + new Date(end));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (now > end)
|
|
|
|
Log.e("Schedule invalid now=" + new Date(now) + " end=" + new Date(end));
|
2019-12-07 14:14:35 +00:00
|
|
|
if (start > end)
|
|
|
|
Log.e("Schedule invalid start=" + new Date(start) + " end=" + new Date(end));
|
2019-04-27 16:07:06 +00:00
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
return new long[]{start, end};
|
2019-02-28 07:55:08 +00:00
|
|
|
}
|
|
|
|
|
2021-03-29 19:11:13 +00:00
|
|
|
static void scheduleWatchdog(Context context) {
|
|
|
|
Intent intent = new Intent(context, ServiceSynchronize.class)
|
|
|
|
.setAction("watchdog");
|
|
|
|
PendingIntent pi;
|
|
|
|
if (isBackgroundService(context))
|
|
|
|
pi = PendingIntentCompat.getService(context, PI_WATCHDOG, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
|
|
|
else
|
|
|
|
pi = PendingIntentCompat.getForegroundService(context, PI_WATCHDOG, intent, PendingIntent.FLAG_UPDATE_CURRENT);
|
|
|
|
|
|
|
|
AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
boolean watchdog = prefs.getBoolean("watchdog", true);
|
|
|
|
boolean enabled = prefs.getBoolean("enabled", true);
|
|
|
|
if (watchdog && enabled) {
|
|
|
|
long now = new Date().getTime();
|
2021-06-16 10:53:04 +00:00
|
|
|
long next = now - now % WATCHDOG_INTERVAL + WATCHDOG_INTERVAL + WATCHDOG_INTERVAL / 4;
|
2021-03-30 08:02:55 +00:00
|
|
|
if (next < now + WATCHDOG_INTERVAL / 5)
|
|
|
|
next += WATCHDOG_INTERVAL;
|
2021-06-16 10:53:04 +00:00
|
|
|
EntityLog.log(context, "Watchdog next=" + new Date(next));
|
2021-04-27 05:53:09 +00:00
|
|
|
AlarmManagerCompatEx.setAndAllowWhileIdle(context, am, AlarmManager.RTC_WAKEUP, next, pi);
|
2021-03-29 19:11:13 +00:00
|
|
|
} else
|
|
|
|
am.cancel(pi);
|
|
|
|
}
|
|
|
|
|
2019-12-09 18:44:27 +00:00
|
|
|
static void eval(Context context, String reason) {
|
2020-05-27 07:22:30 +00:00
|
|
|
start(context,
|
2019-02-14 12:28:03 +00:00
|
|
|
new Intent(context, ServiceSynchronize.class)
|
2019-12-07 14:14:35 +00:00
|
|
|
.setAction("eval")
|
2019-12-09 18:44:27 +00:00
|
|
|
.putExtra("reason", reason));
|
|
|
|
}
|
|
|
|
|
2020-03-30 11:07:37 +00:00
|
|
|
static void reload(Context context, Long account, boolean force, String reason) {
|
2020-05-27 07:22:30 +00:00
|
|
|
start(context,
|
2019-12-09 18:44:27 +00:00
|
|
|
new Intent(context, ServiceSynchronize.class)
|
2019-12-09 21:26:29 +00:00
|
|
|
.setAction("reload")
|
|
|
|
.putExtra("account", account == null ? -1 : account)
|
2020-03-30 11:07:37 +00:00
|
|
|
.putExtra("force", force)
|
2019-12-07 14:14:35 +00:00
|
|
|
.putExtra("reason", reason));
|
2019-04-17 08:53:15 +00:00
|
|
|
}
|
|
|
|
|
2019-12-07 14:14:35 +00:00
|
|
|
static void reschedule(Context context) {
|
2020-05-27 07:22:30 +00:00
|
|
|
start(context,
|
2018-11-27 15:36:42 +00:00
|
|
|
new Intent(context, ServiceSynchronize.class)
|
2019-12-07 14:14:35 +00:00
|
|
|
.setAction("alarm"));
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|
2020-03-25 09:44:50 +00:00
|
|
|
|
2020-07-25 17:54:28 +00:00
|
|
|
static void state(Context context, boolean foreground) {
|
|
|
|
start(context,
|
|
|
|
new Intent(context, ServiceSynchronize.class)
|
|
|
|
.setAction("state")
|
|
|
|
.putExtra("foreground", foreground));
|
|
|
|
}
|
|
|
|
|
2020-03-25 09:44:50 +00:00
|
|
|
static void watchdog(Context context) {
|
2021-03-29 18:08:35 +00:00
|
|
|
start(context,
|
|
|
|
new Intent(context, ServiceSynchronize.class)
|
|
|
|
.setAction("watchdog"));
|
2020-03-25 09:44:50 +00:00
|
|
|
}
|
2020-05-27 07:22:30 +00:00
|
|
|
|
2021-07-15 19:01:50 +00:00
|
|
|
static void stop(Context context) {
|
2021-02-24 14:58:53 +00:00
|
|
|
context.stopService(new Intent(context, ServiceSynchronize.class));
|
2021-07-15 19:01:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void restart(Context context) {
|
|
|
|
stop(context);
|
2021-02-24 14:58:53 +00:00
|
|
|
eval(context, "restart");
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:22:30 +00:00
|
|
|
private static void start(Context context, Intent intent) {
|
2020-10-16 11:02:32 +00:00
|
|
|
if (isBackgroundService(context))
|
2020-05-27 07:22:30 +00:00
|
|
|
context.startService(intent);
|
2021-03-27 14:50:39 +00:00
|
|
|
else
|
2021-03-24 17:55:18 +00:00
|
|
|
try {
|
|
|
|
ContextCompat.startForegroundService(context, intent);
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
}
|
2020-05-27 07:22:30 +00:00
|
|
|
}
|
2020-10-16 11:02:32 +00:00
|
|
|
|
|
|
|
private static boolean isBackgroundService(Context context) {
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
return prefs.getBoolean("background_service", false);
|
|
|
|
}
|
2018-08-02 13:33:06 +00:00
|
|
|
}
|