mirror of
https://github.com/ArcaneChat/android.git
synced 2026-07-03 14:05:24 +02:00
Merge pull request #1108 from deltachat/streamline-notifications
streamline background notifications
This commit is contained in:
@@ -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">
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user