kopia lustrzana https://github.com/ryukoposting/Signal-Android
317 wiersze
11 KiB
Java
317 wiersze
11 KiB
Java
package org.thoughtcrime.securesms.service;
|
|
|
|
import android.app.PendingIntent;
|
|
import android.app.Service;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.os.Binder;
|
|
import android.os.Build;
|
|
import android.os.IBinder;
|
|
|
|
import androidx.annotation.DrawableRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.core.app.NotificationCompat;
|
|
import androidx.core.content.ContextCompat;
|
|
|
|
import org.signal.core.util.PendingIntentFlags;
|
|
import org.signal.core.util.logging.Log;
|
|
import org.thoughtcrime.securesms.MainActivity;
|
|
import org.thoughtcrime.securesms.R;
|
|
import org.thoughtcrime.securesms.jobs.ForegroundServiceUtil;
|
|
import org.thoughtcrime.securesms.jobs.UnableToStartException;
|
|
import org.thoughtcrime.securesms.notifications.NotificationChannels;
|
|
import org.whispersystems.signalservice.api.util.Preconditions;
|
|
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Locale;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
public final class GenericForegroundService extends Service {
|
|
|
|
private static final String TAG = Log.tag(GenericForegroundService.class);
|
|
|
|
private final IBinder binder = new LocalBinder();
|
|
|
|
private static final int NOTIFICATION_ID = 827353982;
|
|
private static final String EXTRA_TITLE = "extra_title";
|
|
private static final String EXTRA_CHANNEL_ID = "extra_channel_id";
|
|
private static final String EXTRA_ICON_RES = "extra_icon_res";
|
|
private static final String EXTRA_ID = "extra_id";
|
|
private static final String EXTRA_PROGRESS = "extra_progress";
|
|
private static final String EXTRA_PROGRESS_MAX = "extra_progress_max";
|
|
private static final String EXTRA_PROGRESS_INDETERMINATE = "extra_progress_indeterminate";
|
|
|
|
private static final String ACTION_START = "start";
|
|
private static final String ACTION_STOP = "stop";
|
|
|
|
private static final AtomicInteger NEXT_ID = new AtomicInteger();
|
|
|
|
private final LinkedHashMap<Integer, Entry> allActiveMessages = new LinkedHashMap<>();
|
|
|
|
private static final Entry DEFAULTS = new Entry("", NotificationChannels.OTHER, R.drawable.ic_notification, -1, 0, 0, false);
|
|
|
|
private @Nullable Entry lastPosted;
|
|
|
|
@Override
|
|
public int onStartCommand(Intent intent, int flags, int startId) {
|
|
if (intent == null) {
|
|
throw new IllegalStateException("Intent needs to be non-null.");
|
|
}
|
|
|
|
synchronized (GenericForegroundService.class) {
|
|
String action = intent.getAction();
|
|
|
|
if (action != null) {
|
|
if (ACTION_START.equals(action)) handleStart(intent);
|
|
else if (ACTION_STOP .equals(action)) handleStop(intent);
|
|
else throw new IllegalStateException(String.format("Action needs to be %s or %s.", ACTION_START, ACTION_STOP));
|
|
|
|
updateNotification();
|
|
}
|
|
|
|
return START_NOT_STICKY;
|
|
}
|
|
}
|
|
|
|
private synchronized void updateNotification() {
|
|
Iterator<Entry> iterator = allActiveMessages.values().iterator();
|
|
|
|
if (iterator.hasNext()) {
|
|
postObligatoryForegroundNotification(iterator.next());
|
|
} else {
|
|
Log.i(TAG, "Last request. Ending foreground service.");
|
|
postObligatoryForegroundNotification(lastPosted != null ? lastPosted : DEFAULTS);
|
|
stopForeground(true);
|
|
stopSelf();
|
|
}
|
|
}
|
|
|
|
private synchronized void handleStart(@NonNull Intent intent) {
|
|
Entry entry = Entry.fromIntent(intent);
|
|
|
|
Log.i(TAG, String.format(Locale.US, "handleStart() %s", entry));
|
|
|
|
allActiveMessages.put(entry.id, entry);
|
|
}
|
|
|
|
private synchronized void handleStop(@NonNull Intent intent) {
|
|
Log.i(TAG, "handleStop()");
|
|
|
|
int id = intent.getIntExtra(EXTRA_ID, -1);
|
|
|
|
Entry removed = allActiveMessages.remove(id);
|
|
|
|
if (removed == null) {
|
|
Log.w(TAG, "Could not find entry to remove");
|
|
}
|
|
}
|
|
|
|
private void postObligatoryForegroundNotification(@NonNull Entry active) {
|
|
lastPosted = active;
|
|
// TODO [greyson] Navigation
|
|
startForeground(NOTIFICATION_ID, new NotificationCompat.Builder(this, active.channelId)
|
|
.setSmallIcon(active.iconRes)
|
|
.setContentTitle(active.title)
|
|
.setProgress(active.progressMax, active.progress, active.indeterminate)
|
|
.setContentIntent(PendingIntent.getActivity(this, 0, MainActivity.clearTop(this), PendingIntentFlags.mutable()))
|
|
.setVibrate(new long[]{0})
|
|
.build());
|
|
}
|
|
|
|
@Override
|
|
public IBinder onBind(Intent intent) {
|
|
return binder;
|
|
}
|
|
|
|
/**
|
|
* Waits for {@param delayMillis} ms before starting the foreground task.
|
|
* <p>
|
|
* The delayed notification controller can also shown on demand and promoted to a regular notification controller to update the message etc.
|
|
*
|
|
* Do not call this method on API > 31
|
|
*/
|
|
public static DelayedNotificationController startForegroundTaskDelayed(@NonNull Context context, @NonNull String task, long delayMillis, @DrawableRes int iconRes) {
|
|
Preconditions.checkArgument(Build.VERSION.SDK_INT < 31);
|
|
|
|
return DelayedNotificationController.create(delayMillis, () -> {
|
|
try {
|
|
return startForegroundTask(context, task, DEFAULTS.channelId, iconRes);
|
|
} catch (UnableToStartException e) {
|
|
Log.w(TAG, "This should not happen on API < 31", e);
|
|
throw new AssertionError(e.getCause());
|
|
}
|
|
});
|
|
}
|
|
|
|
public static NotificationController startForegroundTask(@NonNull Context context, @NonNull String task) throws UnableToStartException {
|
|
return startForegroundTask(context, task, DEFAULTS.channelId);
|
|
}
|
|
|
|
public static NotificationController startForegroundTask(@NonNull Context context, @NonNull String task, @NonNull String channelId)
|
|
throws UnableToStartException
|
|
{
|
|
return startForegroundTask(context, task, channelId, DEFAULTS.iconRes);
|
|
}
|
|
|
|
public static NotificationController startForegroundTask(
|
|
@NonNull Context context,
|
|
@NonNull String task,
|
|
@NonNull String channelId,
|
|
@DrawableRes int iconRes)
|
|
throws UnableToStartException
|
|
{
|
|
final int id = NEXT_ID.getAndIncrement();
|
|
|
|
Intent intent = new Intent(context, GenericForegroundService.class);
|
|
intent.setAction(ACTION_START);
|
|
intent.putExtra(EXTRA_TITLE, task);
|
|
intent.putExtra(EXTRA_CHANNEL_ID, channelId);
|
|
intent.putExtra(EXTRA_ICON_RES, iconRes);
|
|
intent.putExtra(EXTRA_ID, id);
|
|
|
|
Log.i(TAG, String.format(Locale.US, "Starting foreground service (%s) id=%d", task, id));
|
|
|
|
ForegroundServiceUtil.start(context, intent);
|
|
|
|
return new NotificationController(context, id);
|
|
}
|
|
|
|
public static void stopForegroundTask(@NonNull Context context, int id) {
|
|
Intent intent = new Intent(context, GenericForegroundService.class);
|
|
intent.setAction(ACTION_STOP);
|
|
intent.putExtra(EXTRA_ID, id);
|
|
|
|
Log.i(TAG, String.format(Locale.US, "Stopping foreground service id=%d", id));
|
|
ForegroundServiceUtil.startWhenCapableOrThrow(context, intent);
|
|
}
|
|
|
|
synchronized void replaceTitle(int id, @NonNull String title) {
|
|
Entry oldEntry = allActiveMessages.get(id);
|
|
|
|
if (oldEntry == null) {
|
|
Log.w(TAG, "Failed to replace notification, it was not found");
|
|
return;
|
|
}
|
|
|
|
Entry newEntry = new Entry(title, oldEntry.channelId, oldEntry.iconRes, oldEntry.id, oldEntry.progressMax, oldEntry.progress, oldEntry.indeterminate);
|
|
|
|
if (oldEntry.equals(newEntry)) {
|
|
Log.d(TAG, String.format("handleReplace() skip, no change %s", newEntry));
|
|
return;
|
|
}
|
|
|
|
Log.i(TAG, String.format("handleReplace() %s", newEntry));
|
|
|
|
allActiveMessages.put(newEntry.id, newEntry);
|
|
|
|
updateNotification();
|
|
}
|
|
|
|
synchronized void replaceProgress(int id, int progressMax, int progress, boolean indeterminate) {
|
|
Entry oldEntry = allActiveMessages.get(id);
|
|
|
|
if (oldEntry == null) {
|
|
Log.w(TAG, "Failed to replace notification, it was not found");
|
|
return;
|
|
}
|
|
|
|
Entry newEntry = new Entry(oldEntry.title, oldEntry.channelId, oldEntry.iconRes, oldEntry.id, progressMax, progress, indeterminate);
|
|
|
|
if (oldEntry.equals(newEntry)) {
|
|
Log.d(TAG, String.format("handleReplace() skip, no change %s", newEntry));
|
|
return;
|
|
}
|
|
|
|
Log.i(TAG, String.format("handleReplace() %s", newEntry));
|
|
|
|
allActiveMessages.put(newEntry.id, newEntry);
|
|
|
|
updateNotification();
|
|
}
|
|
|
|
private static class Entry {
|
|
final @NonNull String title;
|
|
final @NonNull String channelId;
|
|
final int id;
|
|
final @DrawableRes int iconRes;
|
|
final int progress;
|
|
final int progressMax;
|
|
final boolean indeterminate;
|
|
|
|
private Entry(@NonNull String title, @NonNull String channelId, @DrawableRes int iconRes, int id, int progressMax, int progress, boolean indeterminate) {
|
|
this.title = title;
|
|
this.channelId = channelId;
|
|
this.iconRes = iconRes;
|
|
this.id = id;
|
|
this.progress = progress;
|
|
this.progressMax = progressMax;
|
|
this.indeterminate = indeterminate;
|
|
}
|
|
|
|
private static Entry fromIntent(@NonNull Intent intent) {
|
|
int id = intent.getIntExtra(EXTRA_ID, DEFAULTS.id);
|
|
|
|
String title = intent.getStringExtra(EXTRA_TITLE);
|
|
if (title == null) title = DEFAULTS.title;
|
|
|
|
String channelId = intent.getStringExtra(EXTRA_CHANNEL_ID);
|
|
if (channelId == null) channelId = DEFAULTS.channelId;
|
|
|
|
int iconRes = intent.getIntExtra(EXTRA_ICON_RES, DEFAULTS.iconRes);
|
|
int progress = intent.getIntExtra(EXTRA_PROGRESS, DEFAULTS.progress);
|
|
int progressMax = intent.getIntExtra(EXTRA_PROGRESS_MAX, DEFAULTS.progressMax);
|
|
boolean indeterminate = intent.getBooleanExtra(EXTRA_PROGRESS_INDETERMINATE, DEFAULTS.indeterminate);
|
|
|
|
return new Entry(title, channelId, iconRes, id, progressMax, progress, indeterminate);
|
|
}
|
|
|
|
@Override
|
|
public @NonNull String toString() {
|
|
return String.format(Locale.US, "ChannelId: %s Id: %d Progress: %d/%d %s", channelId, id, progress, progressMax, indeterminate ? "indeterminate" : "determinate");
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
|
|
Entry entry = (Entry) o;
|
|
return id == entry.id &&
|
|
iconRes == entry.iconRes &&
|
|
progress == entry.progress &&
|
|
progressMax == entry.progressMax &&
|
|
indeterminate == entry.indeterminate &&
|
|
Objects.equals(title, entry.title) &&
|
|
Objects.equals(channelId, entry.channelId);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int hashCode = title.hashCode();
|
|
hashCode *= 31;
|
|
hashCode += channelId.hashCode();
|
|
hashCode *= 31;
|
|
hashCode += id;
|
|
hashCode *= 31;
|
|
hashCode += iconRes;
|
|
hashCode *= 31;
|
|
hashCode += progress;
|
|
hashCode *= 31;
|
|
hashCode += progressMax;
|
|
hashCode *= 31;
|
|
hashCode += indeterminate ? 1 : 0;
|
|
return hashCode;
|
|
}
|
|
}
|
|
|
|
class LocalBinder extends Binder {
|
|
GenericForegroundService getService() {
|
|
// Return this instance of LocalService so clients can call public methods
|
|
return GenericForegroundService.this;
|
|
}
|
|
}
|
|
}
|