Merge pull request #1108 from deltachat/streamline-notifications

streamline background notifications
This commit is contained in:
cyBerta
2019-11-11 12:33:19 +01:00
committed by GitHub
9 changed files with 83 additions and 197 deletions
-2
View File
@@ -276,8 +276,6 @@
</intent-filter>
</service>
<receiver android:name=".connect.TimerReceiver" android:enabled="true"/>
<receiver android:name=".notifications.MarkReadReceiver"
android:enabled="true"
android:exported="false">
+1
View File
@@ -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'
@@ -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
@@ -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);
}
}
@@ -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
}
}
@@ -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
@@ -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();
}
}
@@ -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);
}
}
}
@@ -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);
}
}