diff --git a/AndroidManifest.xml b/AndroidManifest.xml index 6ab1213b2..5ee143e04 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -276,8 +276,6 @@ - - diff --git a/build.gradle b/build.gradle index ce0e78651..f8139f4d9 100644 --- a/build.gradle +++ b/build.gradle @@ -37,6 +37,7 @@ dependencies { implementation 'androidx.exifinterface:exifinterface:1.0.0' implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0' implementation 'androidx.lifecycle:lifecycle-common-java8:2.1.0' + implementation 'androidx.work:work-runtime:2.2.0' implementation 'com.google.android.exoplayer:exoplayer-core:2.9.1' // plays video and audio implementation 'com.google.android.exoplayer:exoplayer-ui:2.9.1' implementation 'androidx.constraintlayout:constraintlayout:1.1.3' diff --git a/src/org/thoughtcrime/securesms/ApplicationContext.java b/src/org/thoughtcrime/securesms/ApplicationContext.java index ba80e22e3..23e7d79f6 100644 --- a/src/org/thoughtcrime/securesms/ApplicationContext.java +++ b/src/org/thoughtcrime/securesms/ApplicationContext.java @@ -4,6 +4,11 @@ import android.annotation.SuppressLint; import androidx.lifecycle.DefaultLifecycleObserver; import androidx.lifecycle.LifecycleOwner; import androidx.lifecycle.ProcessLifecycleOwner; +import androidx.work.Constraints; +import androidx.work.ExistingPeriodicWorkPolicy; +import androidx.work.NetworkType; +import androidx.work.PeriodicWorkRequest; +import androidx.work.WorkManager; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; @@ -15,6 +20,7 @@ import com.b44t.messenger.DcContext; import com.b44t.messenger.DcEventCenter; import org.thoughtcrime.securesms.connect.ApplicationDcContext; +import org.thoughtcrime.securesms.connect.FetchWorker; import org.thoughtcrime.securesms.crypto.PRNGFixes; import org.thoughtcrime.securesms.geolocation.DcLocationManager; import org.thoughtcrime.securesms.jobmanager.JobManager; @@ -23,6 +29,8 @@ import org.thoughtcrime.securesms.util.AndroidSignalProtocolLogger; import org.thoughtcrime.securesms.util.DynamicLanguage; import org.thoughtcrime.securesms.util.ScreenLockUtil; import org.thoughtcrime.securesms.util.SignalProtocolLoggerProvider; + +import java.util.concurrent.TimeUnit; //import com.squareup.leakcanary.LeakCanary; public class ApplicationContext extends MultiDexApplication implements DefaultLifecycleObserver { @@ -74,6 +82,25 @@ public class ApplicationContext extends MultiDexApplication implements DefaultLi dcContext.setStockTranslations(); } }, filter); + + // MAYBE TODO: i think the ApplicationContext is also created + // when the app is stated by FetchWorker timeouts. + // in this case, the normal threads shall not be started. + Constraints constraints = new Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) + .build(); + PeriodicWorkRequest fetchWorkRequest = new PeriodicWorkRequest.Builder( + FetchWorker.class, + PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS, // usually 15 minutes + TimeUnit.MILLISECONDS, + PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS, // the start may be preferred by up to 5 minutes, so we run every 10-15 minutes + TimeUnit.MILLISECONDS) + .setConstraints(constraints) + .build(); + WorkManager.getInstance(this).enqueueUniquePeriodicWork( + "FetchWorker", + ExistingPeriodicWorkPolicy.KEEP, + fetchWorkRequest); } @Override diff --git a/src/org/thoughtcrime/securesms/connect/ApplicationDcContext.java b/src/org/thoughtcrime/securesms/connect/ApplicationDcContext.java index 84025ca26..dfc47d5b7 100644 --- a/src/org/thoughtcrime/securesms/connect/ApplicationDcContext.java +++ b/src/org/thoughtcrime/securesms/connect/ApplicationDcContext.java @@ -71,9 +71,6 @@ public class ApplicationDcContext extends DcContext { smtpWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "smtpWakeLock"); smtpWakeLock.setReferenceCounted(false); // if the idle-thread is killed for any reasons, it is better not to rely on reference counting - afterForegroundWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "afterForegroundWakeLock"); - afterForegroundWakeLock.setReferenceCounted(false); - } catch (Exception e) { Log.e(TAG, "Cannot create wakeLocks"); } @@ -81,8 +78,6 @@ public class ApplicationDcContext extends DcContext { new ForegroundDetector(ApplicationContext.getInstance(context)); startThreads(0); - TimerReceiver.scheduleNextAlarm(context); - BroadcastReceiver networkStateReceiver = new NetworkStateReceiver(); context.registerReceiver(networkStateReceiver, new IntentFilter(android.net.ConnectivityManager.CONNECTIVITY_ACTION)); @@ -293,28 +288,22 @@ public class ApplicationDcContext extends DcContext { **********************************************************************************************/ private final Object threadsCritical = new Object(); + private final Object incLoopsCritical= new Object(); - private boolean imapThreadStartedVal; - private final Object imapThreadStartedCond = new Object(); public Thread imapThread = null; private PowerManager.WakeLock imapWakeLock = null; + private int inboxLoops = 0; - private boolean mvboxThreadStartedVal; - private final Object mvboxThreadStartedCond = new Object(); public Thread mvboxThread = null; private PowerManager.WakeLock mvboxWakeLock = null; + private int mvboxLoops = 0; - private boolean sentboxThreadStartedVal; - private final Object sentboxThreadStartedCond = new Object(); public Thread sentboxThread = null; private PowerManager.WakeLock sentboxWakeLock = null; - private boolean smtpThreadStartedVal; - private final Object smtpThreadStartedCond = new Object(); public Thread smtpThread = null; private PowerManager.WakeLock smtpWakeLock = null; - - public PowerManager.WakeLock afterForegroundWakeLock = null; + private int smtpLoops = 0; public final static int INTERRUPT_IDLE = 0x01; // interrupt idle if the thread is already running @@ -323,28 +312,16 @@ public class ApplicationDcContext extends DcContext { if (imapThread == null || !imapThread.isAlive()) { - synchronized (imapThreadStartedCond) { - imapThreadStartedVal = false; - } - imapThread = new Thread(() -> { - // raise the starting condition - // after acquiring a wakelock so that the process is not terminated. - // as imapWakeLock is not reference counted that would result in a wakelock-gap is not needed here. - imapWakeLock.acquire(); - synchronized (imapThreadStartedCond) { - imapThreadStartedVal = true; - imapThreadStartedCond.notifyAll(); - } - Log.i(TAG, "###################### IMAP-Thread started. ######################"); - - while (true) { imapWakeLock.acquire(); performImapJobs(); performImapFetch(); imapWakeLock.release(); + synchronized (incLoopsCritical) { + inboxLoops++; + } performImapIdle(); } }, "imapThread"); @@ -359,25 +336,16 @@ public class ApplicationDcContext extends DcContext { if (mvboxThread == null || !mvboxThread.isAlive()) { - synchronized (mvboxThreadStartedCond) { - mvboxThreadStartedVal = false; - } - mvboxThread = new Thread(() -> { - mvboxWakeLock.acquire(); - synchronized (mvboxThreadStartedCond) { - mvboxThreadStartedVal = true; - mvboxThreadStartedCond.notifyAll(); - } - Log.i(TAG, "###################### MVBOX-Thread started. ######################"); - - while (true) { mvboxWakeLock.acquire(); performMvboxJobs(); performMvboxFetch(); mvboxWakeLock.release(); + synchronized (incLoopsCritical) { + mvboxLoops++; + } performMvboxIdle(); } }, "mvboxThread"); @@ -392,20 +360,8 @@ public class ApplicationDcContext extends DcContext { if (sentboxThread == null || !sentboxThread.isAlive()) { - synchronized (sentboxThreadStartedCond) { - sentboxThreadStartedVal = false; - } - sentboxThread = new Thread(() -> { - sentboxWakeLock.acquire(); - synchronized (sentboxThreadStartedCond) { - sentboxThreadStartedVal = true; - sentboxThreadStartedCond.notifyAll(); - } - Log.i(TAG, "###################### SENTBOX-Thread started. ######################"); - - while (true) { sentboxWakeLock.acquire(); performSentboxJobs(); @@ -422,27 +378,16 @@ public class ApplicationDcContext extends DcContext { } } - if (smtpThread == null || !smtpThread.isAlive()) { - - synchronized (smtpThreadStartedCond) { - smtpThreadStartedVal = false; - } - smtpThread = new Thread(() -> { - smtpWakeLock.acquire(); - synchronized (smtpThreadStartedCond) { - smtpThreadStartedVal = true; - smtpThreadStartedCond.notifyAll(); - } - Log.i(TAG, "###################### SMTP-Thread started. ######################"); - - while (true) { smtpWakeLock.acquire(); performSmtpJobs(); smtpWakeLock.release(); + synchronized (incLoopsCritical) { + smtpLoops++; + } performSmtpIdle(); } }, "smtpThread"); @@ -452,33 +397,14 @@ public class ApplicationDcContext extends DcContext { } } - public void waitForThreadsRunning() { - try { - synchronized (imapThreadStartedCond) { - while (!imapThreadStartedVal) { - imapThreadStartedCond.wait(); + public void waitForThreadsExecutedOnce() { + while(true) { + synchronized (incLoopsCritical) { + if(inboxLoops>0 && mvboxLoops>0 && smtpLoops>0) { + break; } } - - synchronized (mvboxThreadStartedCond) { - while (!mvboxThreadStartedVal) { - mvboxThreadStartedCond.wait(); - } - } - - synchronized (sentboxThreadStartedCond) { - while (!sentboxThreadStartedVal) { - sentboxThreadStartedCond.wait(); - } - } - - synchronized (smtpThreadStartedCond) { - while (!smtpThreadStartedVal) { - smtpThreadStartedCond.wait(); - } - } - } catch (Exception e) { - e.printStackTrace(); + Util.sleep(500); } } diff --git a/src/org/thoughtcrime/securesms/connect/FetchWorker.java b/src/org/thoughtcrime/securesms/connect/FetchWorker.java new file mode 100644 index 000000000..2fe3da400 --- /dev/null +++ b/src/org/thoughtcrime/securesms/connect/FetchWorker.java @@ -0,0 +1,35 @@ +package org.thoughtcrime.securesms.connect; + +import android.content.Context; +import android.util.Log; + +import androidx.annotation.NonNull; +import androidx.work.Worker; +import androidx.work.WorkerParameters; + +public class FetchWorker extends Worker { + private @NonNull Context context; + + public FetchWorker( + @NonNull Context context, + @NonNull WorkerParameters params) { + super(context, params); + this.context = context; + } + + @Override + public @NonNull Result doWork() { + // MAYBE TODO: + // - when no threads are running: fetch-inbox, maybe fetch-mvbox, do smtp-jobs. + // fetch-sendbox is not needed as these messages shall not be notified. + // - when threads are running: interrupt-all-idle + + Log.i("DeltaChat", "-------------------- FetchWorker.doWork() started --------------------"); + ApplicationDcContext dcContext = DcHelper.getContext(context); + dcContext.startThreads(ApplicationDcContext.INTERRUPT_IDLE); + dcContext.waitForThreadsExecutedOnce(); + Log.i("DeltaChat", "-------------------- FetchWorker.doWork() done --------------------"); + + return Result.success(); // when returning, the os may terminate the app again + } +} diff --git a/src/org/thoughtcrime/securesms/connect/ForegroundDetector.java b/src/org/thoughtcrime/securesms/connect/ForegroundDetector.java index efb04ed5c..76a706b42 100644 --- a/src/org/thoughtcrime/securesms/connect/ForegroundDetector.java +++ b/src/org/thoughtcrime/securesms/connect/ForegroundDetector.java @@ -38,8 +38,7 @@ public class ForegroundDetector implements Application.ActivityLifecycleCallback refs++; activity.stopService(new Intent(activity, KeepAliveService.class)); - - // probably no need to interrupt idle as this is done in the TimerReceiver every 5 minutes + application.dcContext.startThreads(0); } @@ -51,9 +50,6 @@ public class ForegroundDetector implements Application.ActivityLifecycleCallback } refs--; - if (refs == 0) { - application.dcContext.afterForegroundWakeLock.acquire(60*1000); - } } @Override diff --git a/src/org/thoughtcrime/securesms/connect/NetworkStateReceiver.java b/src/org/thoughtcrime/securesms/connect/NetworkStateReceiver.java index 5c54bf3ed..3155074a5 100644 --- a/src/org/thoughtcrime/securesms/connect/NetworkStateReceiver.java +++ b/src/org/thoughtcrime/securesms/connect/NetworkStateReceiver.java @@ -7,9 +7,6 @@ import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.util.Log; -import org.thoughtcrime.securesms.connect.ApplicationDcContext; -import org.thoughtcrime.securesms.connect.DcHelper; - public class NetworkStateReceiver extends BroadcastReceiver { @Override @@ -22,8 +19,6 @@ public class NetworkStateReceiver extends BroadcastReceiver { if (ni != null && ni.getState() == NetworkInfo.State.CONNECTED) { Log.i("DeltaChat", "++++++++++++++++++ Connected ++++++++++++++++++"); ApplicationDcContext dcContext = DcHelper.getContext(context); - dcContext.startThreads(0); // no need to interrupt idle as maybeNetwork() is called below - dcContext.waitForThreadsRunning(); dcContext.maybeNetwork(); } } diff --git a/src/org/thoughtcrime/securesms/connect/TimerReceiver.java b/src/org/thoughtcrime/securesms/connect/TimerReceiver.java deleted file mode 100644 index b6a6cdb7d..000000000 --- a/src/org/thoughtcrime/securesms/connect/TimerReceiver.java +++ /dev/null @@ -1,58 +0,0 @@ -// restart the smtp and imap threads every 5 minutes if they were killed by the os. -// however, we try to prevent the killing by the permanent notification KeepAliveService. - -package org.thoughtcrime.securesms.connect; - -import android.app.Activity; -import android.app.AlarmManager; -import android.app.PendingIntent; -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.os.Build; -import android.util.Log; - -import org.thoughtcrime.securesms.connect.ApplicationDcContext; -import org.thoughtcrime.securesms.connect.DcHelper; - -public class TimerReceiver extends BroadcastReceiver { - - // we trigger an interupt-idle or a start-threads every 5 minutes, - // normally, the core reconnects on its own, however, if for some reasons, - // the thread was killed, we recreate it here. - // also the IMAP NOOP is helpful on some servers, see above. - // (re-doing IMAP-IDLE should imply a NOOP call then, https://www.isode.com/whitepapers/imap-idle.html ) - public void onReceive(Context context, Intent intent) { - - Log.i("DeltaChat", "-------------------- on receive timer --------------------"); - - scheduleNextAlarm(context); - - ApplicationDcContext dcContext = DcHelper.getContext(context); - - dcContext.startThreads(ApplicationDcContext.INTERRUPT_IDLE); - dcContext.waitForThreadsRunning(); - } - - public static void scheduleNextAlarm(Context context) - { - try { - Intent intent = new Intent(context, TimerReceiver.class); - PendingIntent alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0); - - long triggerAtMillis = System.currentTimeMillis() + 5 * 60 * 1000; - - AlarmManager alarmManager = (AlarmManager) context.getSystemService(Activity.ALARM_SERVICE); - if( Build.VERSION.SDK_INT >= 23 ) { - // a simple AlarmManager.set() is no longer send in the new DOZE mode - alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAtMillis, alarmIntent); - } - else { - alarmManager.set(AlarmManager.RTC_WAKEUP, triggerAtMillis, alarmIntent); - } - } - catch(Exception e) { - Log.e("DeltaChat", "Cannot create alarm.", e); - } - } -} diff --git a/src/org/thoughtcrime/securesms/service/PersistentAlarmManagerListener.java b/src/org/thoughtcrime/securesms/service/PersistentAlarmManagerListener.java deleted file mode 100644 index f592d9f98..000000000 --- a/src/org/thoughtcrime/securesms/service/PersistentAlarmManagerListener.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.thoughtcrime.securesms.service; - - -import android.app.AlarmManager; -import android.app.PendingIntent; -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.util.Log; - -public abstract class PersistentAlarmManagerListener extends BroadcastReceiver { - - private static final String TAG = PersistentAlarmManagerListener.class.getSimpleName(); - - protected abstract long getNextScheduledExecutionTime(Context context); - protected abstract long onAlarm(Context context, long scheduledTime); - - @Override - public void onReceive(Context context, Intent intent) { - long scheduledTime = getNextScheduledExecutionTime(context); - AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); - Intent alarmIntent = new Intent(context, getClass()); - PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, alarmIntent, 0); - - if (System.currentTimeMillis() >= scheduledTime) { - scheduledTime = onAlarm(context, scheduledTime); - } - - Log.w(TAG, getClass() + " scheduling for: " + scheduledTime); - - alarmManager.cancel(pendingIntent); - alarmManager.set(AlarmManager.RTC_WAKEUP, scheduledTime, pendingIntent); - } -}