From 1dd1da30d2f9553ad8cada14a431904ed39aec9c Mon Sep 17 00:00:00 2001 From: uabdullah Date: Fri, 2 Feb 2018 09:27:24 -0800 Subject: Refresh annotated call log from the voicemail tab This CL copies the code dealing with refreshing the annotated call log from the NewCallLogFragment and applies it to the NewVoicemailFragment. This is necessary since the NewVoicemailFragment should be able to refresh the annotated call log without depending on the user going to the call log fragment for the update. The only thing we don't copy over is the logic and handling when the CP2 info is incomplete for a number (INVALID number), however we do not expect any invalid numbers for voicemail and as such have added an assert for that. Bug: 72523272 Test: Unit Tests PiperOrigin-RevId: 184292549 Change-Id: I2994974fe60221a4854fed5f9d80d3d428449ae9 --- java/com/android/dialer/util/PermissionsUtil.java | 2 + .../voicemail/listui/NewVoicemailFragment.java | 114 ++++++++++++++++++++- 2 files changed, 115 insertions(+), 1 deletion(-) diff --git a/java/com/android/dialer/util/PermissionsUtil.java b/java/com/android/dialer/util/PermissionsUtil.java index 6684f954b..09c2b7f42 100644 --- a/java/com/android/dialer/util/PermissionsUtil.java +++ b/java/com/android/dialer/util/PermissionsUtil.java @@ -25,6 +25,7 @@ import static android.Manifest.permission.READ_CALL_LOG; import static android.Manifest.permission.READ_CONTACTS; import static android.Manifest.permission.READ_PHONE_STATE; import static android.Manifest.permission.READ_VOICEMAIL; +import static android.Manifest.permission.SEND_SMS; import static android.Manifest.permission.WRITE_CALL_LOG; import static android.Manifest.permission.WRITE_CONTACTS; import static android.Manifest.permission.WRITE_VOICEMAIL; @@ -66,6 +67,7 @@ public class PermissionsUtil { WRITE_CALL_LOG, READ_PHONE_STATE, MODIFY_PHONE_STATE, + SEND_SMS, CALL_PHONE, ADD_VOICEMAIL, WRITE_VOICEMAIL, diff --git a/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java index 0d91f0158..8812bcc2f 100644 --- a/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java +++ b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java @@ -27,17 +27,92 @@ import android.support.v7.widget.RecyclerView; import android.view.LayoutInflater; import android.view.View; 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.DialerExecutorComponent; +import com.android.dialer.common.concurrent.ThreadUtil; +import com.android.dialer.common.concurrent.UiListener; import com.android.dialer.database.CallLogQueryHandler; import com.android.dialer.database.CallLogQueryHandler.Listener; +import com.google.common.util.concurrent.ListenableFuture; // TODO(uabdullah): Register content observer for VoicemailContract.Status.CONTENT_URI in onStart /** Fragment for Dialer Voicemail Tab. */ -public final class NewVoicemailFragment extends Fragment implements LoaderCallbacks { +public final class NewVoicemailFragment extends Fragment + implements LoaderCallbacks, CallLogUi { + + /* + * 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 RefreshAnnotatedCallLogWorker refreshAnnotatedCallLogWorker; + private UiListener refreshAnnotatedCallLogListener; + @Nullable private Runnable refreshAnnotatedCallLogRunnable; private RecyclerView recyclerView; private CallLogQueryHandler callLogQueryHandler; + public NewVoicemailFragment() { + LogUtil.enterBlock("NewVoicemailFragment.NewVoicemailFragment"); + } + + @Override + public void onActivityCreated(@Nullable Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + LogUtil.enterBlock("NewVoicemailFragment.onActivityCreated"); + + CallLogComponent component = CallLogComponent.get(getContext()); + CallLogFramework callLogFramework = component.callLogFramework(); + callLogFramework.attachUi(this); + + // TODO(zachh): Use support fragment manager and add support for them in executors library. + refreshAnnotatedCallLogListener = + DialerExecutorComponent.get(getContext()) + .createUiListener( + getActivity().getFragmentManager(), "NewVoicemailFragment.refreshAnnotatedCallLog"); + refreshAnnotatedCallLogWorker = component.getRefreshAnnotatedCallLogWorker(); + } + + @Override + public void onStart() { + super.onStart(); + LogUtil.enterBlock("NewVoicemailFragment.onStart"); + } + + @Override + public void onResume() { + super.onResume(); + + LogUtil.enterBlock("NewCallLogFragment.onResume"); + + CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework(); + callLogFramework.attachUi(this); + + // TODO(zachh): Consider doing this when fragment becomes visible. + refreshAnnotatedCallLog(true /* checkDirty */); + } + + @Override + public void onPause() { + super.onPause(); + + LogUtil.enterBlock("NewVoicemailFragment.onPause"); + + // This is pending work that we don't actually need to follow through with. + ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable); + + CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework(); + callLogFramework.detachUi(); + } + @Nullable @Override public View onCreateView( @@ -49,6 +124,43 @@ public final class NewVoicemailFragment extends Fragment implements LoaderCallba return view; } + private void refreshAnnotatedCallLog(boolean checkDirty) { + LogUtil.enterBlock("NewVoicemailFragment.refreshAnnotatedCallLog"); + + // If we already scheduled a refresh, cancel it and schedule a new one so that repeated requests + // in quick succession don't result in too much work. For example, if we get 10 requests in + // 10ms, and a complete refresh takes a constant 200ms, the refresh will take 300ms (100ms wait + // and 1 iteration @200ms) instead of 2 seconds (10 iterations @ 200ms) since the work requests + // are serialized in RefreshAnnotatedCallLogWorker. + // + // We might get many requests in quick succession, for example, when the simulator inserts + // hundreds of rows into the system call log, or when the data for a new call is incrementally + // written to different columns as it becomes available. + ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable); + + refreshAnnotatedCallLogRunnable = + () -> { + ListenableFuture future = + checkDirty + ? refreshAnnotatedCallLogWorker.refreshWithDirtyCheck() + : refreshAnnotatedCallLogWorker.refreshWithoutDirtyCheck(); + refreshAnnotatedCallLogListener.listen( + getContext(), + future, + unused -> {}, + throwable -> { + throw new RuntimeException(throwable); + }); + }; + ThreadUtil.getUiThreadHandler().postDelayed(refreshAnnotatedCallLogRunnable, WAIT_MILLIS); + } + + @Override + public void invalidateUi() { + LogUtil.enterBlock("NewVoicemailFragment.invalidateUi"); + refreshAnnotatedCallLog(false /* checkDirty */); + } + @Override public Loader onCreateLoader(int id, Bundle args) { LogUtil.enterBlock("NewVoicemailFragment.onCreateLoader"); -- cgit v1.2.3