diff options
Diffstat (limited to 'java/com/android/dialer/calllog')
| -rw-r--r-- | java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java | 61 | ||||
| -rw-r--r-- | java/com/android/dialer/calllog/ui/NewCallLogFragment.java | 38 |
2 files changed, 63 insertions, 36 deletions
diff --git a/java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java b/java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java index 72f73cdaf..d9924b23f 100644 --- a/java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java +++ b/java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java @@ -29,39 +29,74 @@ import com.android.dialer.calllog.datasources.CallLogMutations; import com.android.dialer.calllog.datasources.DataSources; import com.android.dialer.common.Assert; import com.android.dialer.common.LogUtil; -import com.android.dialer.common.concurrent.DialerExecutor.Worker; +import com.android.dialer.common.concurrent.Annotations.UiSerial; import com.android.dialer.inject.ApplicationContext; import com.android.dialer.storage.Unencrypted; +import com.google.common.util.concurrent.ListenableScheduledFuture; +import com.google.common.util.concurrent.ListeningScheduledExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; import javax.inject.Inject; -/** - * Worker which brings the annotated call log up to date, if necessary. - * - * <p>Accepts a boolean which indicates if the dirty check should be skipped. - */ -public class RefreshAnnotatedCallLogWorker implements Worker<Boolean, Void> { +/** Brings the annotated call log up to date, if necessary. */ +public class RefreshAnnotatedCallLogWorker { + + /* + * This is a reasonable time that it might take between related call log writes, that also + * shouldn't slow down single-writes too much. For example, when populating the database using + * the simulator, using this value results in ~6 refresh cycles (on a release build) to write 120 + * call log entries. + */ + private static final long WAIT_MILLIS = 100L; private final Context appContext; private final DataSources dataSources; private final SharedPreferences sharedPreferences; + private final ListeningScheduledExecutorService listeningScheduledExecutorService; + private ListenableScheduledFuture<Void> scheduledFuture; @Inject RefreshAnnotatedCallLogWorker( @ApplicationContext Context appContext, DataSources dataSources, - @Unencrypted SharedPreferences sharedPreferences) { + @Unencrypted SharedPreferences sharedPreferences, + @UiSerial ScheduledExecutorService serialUiExecutorService) { this.appContext = appContext; this.dataSources = dataSources; this.sharedPreferences = sharedPreferences; + this.listeningScheduledExecutorService = + MoreExecutors.listeningDecorator(serialUiExecutorService); } - @Override - public Void doInBackground(Boolean skipDirtyCheck) + /** Checks if the annotated call log is dirty and refreshes it if necessary. */ + public ListenableScheduledFuture<Void> refreshWithDirtyCheck() { + return refresh(true); + } + + /** Refreshes the annotated call log, bypassing dirty checks. */ + public ListenableScheduledFuture<Void> refreshWithoutDirtyCheck() { + return refresh(false); + } + + private ListenableScheduledFuture<Void> refresh(boolean checkDirty) { + if (scheduledFuture != null) { + LogUtil.i("RefreshAnnotatedCallLogWorker.refresh", "cancelling waiting task"); + scheduledFuture.cancel(false /* mayInterrupt */); + } + scheduledFuture = + listeningScheduledExecutorService.schedule( + () -> doInBackground(checkDirty), WAIT_MILLIS, TimeUnit.MILLISECONDS); + return scheduledFuture; + } + + @WorkerThread + private Void doInBackground(boolean checkDirty) throws RemoteException, OperationApplicationException { LogUtil.enterBlock("RefreshAnnotatedCallLogWorker.doInBackground"); long startTime = System.currentTimeMillis(); - checkDirtyAndRebuildIfNecessary(appContext, skipDirtyCheck); + checkDirtyAndRebuildIfNecessary(appContext, checkDirty); LogUtil.i( "RefreshAnnotatedCallLogWorker.doInBackground", "took %dms", @@ -70,7 +105,7 @@ public class RefreshAnnotatedCallLogWorker implements Worker<Boolean, Void> { } @WorkerThread - private void checkDirtyAndRebuildIfNecessary(Context appContext, boolean skipDirtyCheck) + private void checkDirtyAndRebuildIfNecessary(Context appContext, boolean checkDirty) throws RemoteException, OperationApplicationException { Assert.isWorkerThread(); @@ -86,7 +121,7 @@ public class RefreshAnnotatedCallLogWorker implements Worker<Boolean, Void> { "annotated call log has been marked dirty or does not exist"); } - boolean isDirty = skipDirtyCheck || forceRebuildPrefValue || isDirty(appContext); + boolean isDirty = !checkDirty || forceRebuildPrefValue || isDirty(appContext); LogUtil.i( "RefreshAnnotatedCallLogWorker.checkDirtyAndRebuildIfNecessary", diff --git a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java index ab7381347..6833452c6 100644 --- a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java +++ b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java @@ -28,24 +28,18 @@ import android.view.ViewGroup; import com.android.dialer.calllog.CallLogComponent; import com.android.dialer.calllog.CallLogFramework; import com.android.dialer.calllog.CallLogFramework.CallLogUi; +import com.android.dialer.calllog.RefreshAnnotatedCallLogWorker; import com.android.dialer.common.LogUtil; -import com.android.dialer.common.concurrent.DialerExecutor; import com.android.dialer.common.concurrent.DialerExecutorComponent; -import com.android.dialer.common.concurrent.DialerExecutorFactory; +import com.android.dialer.common.concurrent.UiListener; +import com.google.common.util.concurrent.ListenableScheduledFuture; /** The "new" call log fragment implementation, which is built on top of the annotated call log. */ public final class NewCallLogFragment extends Fragment implements CallLogUi, LoaderCallbacks<Cursor> { - /* - * This is a reasonable time that it might take between related call log writes, that also - * shouldn't slow down single-writes too much. For example, when populating the database using - * the simulator, using this value results in ~6 refresh cycles (on a release build) to write 120 - * call log entries. - */ - private static final long WAIT_MILLIS = 100L; - - private DialerExecutor<Boolean> refreshAnnotatedCallLogTask; + private RefreshAnnotatedCallLogWorker refreshAnnotatedCallLogWorker; + private UiListener<Void> refreshAnnotatedCallLogListener; private RecyclerView recyclerView; public NewCallLogFragment() { @@ -62,17 +56,12 @@ public final class NewCallLogFragment extends Fragment CallLogFramework callLogFramework = component.callLogFramework(); callLogFramework.attachUi(this); - DialerExecutorFactory dialerExecutorFactory = - DialerExecutorComponent.get(getContext()).dialerExecutorFactory(); - // TODO(zachh): Use support fragment manager and add support for them in executors library. - refreshAnnotatedCallLogTask = - dialerExecutorFactory - .createUiTaskBuilder( - getActivity().getFragmentManager(), - "NewCallLogFragment.refreshAnnotatedCallLog", - component.getRefreshAnnotatedCallLogWorker()) - .build(); + refreshAnnotatedCallLogListener = + DialerExecutorComponent.get(getContext()) + .createUiListener( + getActivity().getFragmentManager(), "NewCallLogFragment.refreshAnnotatedCallLog"); + refreshAnnotatedCallLogWorker = component.getRefreshAnnotatedCallLogWorker(); } @Override @@ -120,13 +109,16 @@ public final class NewCallLogFragment extends Fragment private void checkAnnotatedCallLogDirtyAndRefreshIfNecessary() { LogUtil.enterBlock("NewCallLogFragment.checkAnnotatedCallLogDirtyAndRefreshIfNecessary"); - refreshAnnotatedCallLogTask.executeSerialWithWait(false /* skipDirtyCheck */, WAIT_MILLIS); + ListenableScheduledFuture<Void> future = refreshAnnotatedCallLogWorker.refreshWithDirtyCheck(); + refreshAnnotatedCallLogListener.listen(future, unused -> {}, RuntimeException::new); } @Override public void invalidateUi() { LogUtil.enterBlock("NewCallLogFragment.invalidateUi"); - refreshAnnotatedCallLogTask.executeSerialWithWait(true /* skipDirtyCheck */, WAIT_MILLIS); + ListenableScheduledFuture<Void> future = + refreshAnnotatedCallLogWorker.refreshWithoutDirtyCheck(); + refreshAnnotatedCallLogListener.listen(future, unused -> {}, RuntimeException::new); } @Override |