diff options
Diffstat (limited to 'java/com/android/dialer')
26 files changed, 680 insertions, 120 deletions
diff --git a/java/com/android/dialer/app/calllog/CallLogAdapter.java b/java/com/android/dialer/app/calllog/CallLogAdapter.java index 51df70219..baca590b5 100644 --- a/java/com/android/dialer/app/calllog/CallLogAdapter.java +++ b/java/com/android/dialer/app/calllog/CallLogAdapter.java @@ -54,6 +54,7 @@ import android.view.ViewGroup; import com.android.contacts.common.ContactsUtils; import com.android.contacts.common.compat.PhoneNumberUtilsCompat; import com.android.contacts.common.preference.ContactsPreferences; +import com.android.dialer.app.DialtactsActivity; import com.android.dialer.app.R; import com.android.dialer.app.calllog.CallLogFragment.CallLogFragmentListener; import com.android.dialer.app.calllog.CallLogGroupBuilder.GroupCreator; @@ -381,9 +382,7 @@ public class CallLogAdapter extends GroupingListAdapter if (viewHolder.callType == CallLog.Calls.MISSED_TYPE) { CallLogAsyncTaskUtil.markCallAsRead(activity, viewHolder.callIds); if (activityType == ACTIVITY_TYPE_DIALTACTS) { - if (v.getContext() instanceof CallLogFragmentListener) { - ((CallLogFragmentListener) v.getContext()).updateTabUnreadCounts(); - } else if (v.getContext() instanceof MainActivityPeer.PeerSupplier) { + if (v.getContext() instanceof MainActivityPeer.PeerSupplier) { // This is really bad, but we must do this to prevent a dependency cycle, enforce // best practices in new code, and avoid refactoring DialtactsActivity. ((FragmentUtilListener) @@ -391,8 +390,7 @@ public class CallLogAdapter extends GroupingListAdapter .getImpl(CallLogFragmentListener.class) .updateTabUnreadCounts(); } else { - throw Assert.createIllegalStateFailException( - "View parent does not implement CallLogFragmentListener"); + ((DialtactsActivity) v.getContext()).updateTabUnreadCounts(); } } } diff --git a/java/com/android/dialer/app/calllog/CallLogNotificationsService.java b/java/com/android/dialer/app/calllog/CallLogNotificationsService.java index 5949141f1..10e30ff72 100644 --- a/java/com/android/dialer/app/calllog/CallLogNotificationsService.java +++ b/java/com/android/dialer/app/calllog/CallLogNotificationsService.java @@ -31,6 +31,7 @@ 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.DialerExecutorComponent; +import com.android.dialer.notification.missedcalls.MissedCallNotificationCanceller; import com.android.dialer.telecom.TelecomUtil; import com.android.dialer.util.PermissionsUtil; @@ -87,14 +88,6 @@ public class CallLogNotificationsService extends IntentService { context.startService(serviceIntent); } - public static void markSingleNewVoicemailAsOld(Context context, @Nullable Uri voicemailUri) { - LogUtil.enterBlock("CallLogNotificationsService.markSingleNewVoicemailAsOld"); - Intent serviceIntent = new Intent(context, CallLogNotificationsService.class); - serviceIntent.setAction(CallLogNotificationsService.ACTION_MARK_SINGLE_NEW_VOICEMAIL_AS_OLD); - serviceIntent.setData(voicemailUri); - context.startService(serviceIntent); - } - public static void cancelAllMissedCalls(Context context) { LogUtil.enterBlock("CallLogNotificationsService.cancelAllMissedCalls"); DialerExecutorComponent.get(context) @@ -175,7 +168,7 @@ public class CallLogNotificationsService extends IntentService { case ACTION_CANCEL_SINGLE_MISSED_CALL: Uri callUri = intent.getData(); CallLogNotificationsQueryHelper.markSingleMissedCallInCallLogAsRead(this, callUri); - MissedCallNotifier.cancelSingleMissedCallNotification(this, callUri); + MissedCallNotificationCanceller.cancelSingle(this, callUri); TelecomUtil.cancelMissedCallsNotification(this); break; case ACTION_CALL_BACK_FROM_MISSED_CALL_NOTIFICATION: @@ -196,7 +189,7 @@ public class CallLogNotificationsService extends IntentService { LogUtil.enterBlock("CallLogNotificationsService.cancelAllMissedCallsBackground"); Assert.isWorkerThread(); CallLogNotificationsQueryHelper.markAllMissedCallsInCallLogAsRead(context); - MissedCallNotifier.cancelAllMissedCallNotifications(context); + MissedCallNotificationCanceller.cancelAll(context); TelecomUtil.cancelMissedCallsNotification(context); } diff --git a/java/com/android/dialer/app/calllog/MissedCallNotifier.java b/java/com/android/dialer/app/calllog/MissedCallNotifier.java index 417f8f0f9..14bbdfa56 100644 --- a/java/com/android/dialer/app/calllog/MissedCallNotifier.java +++ b/java/com/android/dialer/app/calllog/MissedCallNotifier.java @@ -58,7 +58,9 @@ import com.android.dialer.duo.DuoConstants; import com.android.dialer.enrichedcall.FuzzyPhoneNumberMatcher; import com.android.dialer.notification.DialerNotificationManager; import com.android.dialer.notification.NotificationChannelId; -import com.android.dialer.notification.NotificationManagerUtils; +import com.android.dialer.notification.missedcalls.MissedCallConstants; +import com.android.dialer.notification.missedcalls.MissedCallNotificationCanceller; +import com.android.dialer.notification.missedcalls.MissedCallNotificationTags; import com.android.dialer.phonenumbercache.ContactInfo; import com.android.dialer.phonenumberutil.PhoneNumberHelper; import com.android.dialer.precall.PreCall; @@ -71,18 +73,6 @@ import java.util.Set; /** Creates a notification for calls that the user missed (neither answered nor rejected). */ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { - /** Prefix used to generate a unique tag for each missed call notification. */ - private static final String NOTIFICATION_TAG_PREFIX = "MissedCall_"; - /** Common ID for all missed call notifications. */ - private static final int NOTIFICATION_ID = 1; - /** Tag for the group summary notification. */ - private static final String GROUP_SUMMARY_NOTIFICATION_TAG = "GroupSummary_MissedCall"; - /** - * Key used to associate all missed call notifications and the summary as belonging to a single - * group. - */ - private static final String GROUP_KEY = "MissedCallGroup"; - private final Context context; private final CallLogNotificationsQueryHelper callLogNotificationsQueryHelper; @@ -126,7 +116,7 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { if ((newCalls != null && newCalls.isEmpty()) || count == 0) { // No calls to notify about: clear the notification. CallLogNotificationsQueryHelper.markAllMissedCallsInCallLogAsRead(context); - cancelAllMissedCallNotifications(context); + MissedCallNotificationCanceller.cancelAll(context); return; } @@ -226,7 +216,10 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { LogUtil.i("MissedCallNotifier.updateMissedCallNotification", "adding missed call notification"); DialerNotificationManager.notify( - context, GROUP_SUMMARY_NOTIFICATION_TAG, NOTIFICATION_ID, notification); + context, + MissedCallConstants.GROUP_SUMMARY_NOTIFICATION_TAG, + MissedCallConstants.NOTIFICATION_ID, + notification); if (useCallList) { // Do not repost active notifications to prevent erasing post call notes. @@ -240,7 +233,10 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { String callTag = getNotificationTagForCall(call); if (!activeTags.contains(callTag)) { DialerNotificationManager.notify( - context, callTag, NOTIFICATION_ID, getNotificationForCall(call, null)); + context, + callTag, + MissedCallConstants.NOTIFICATION_ID, + getNotificationForCall(call, null)); } } } @@ -286,29 +282,8 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { } } - public static void cancelAllMissedCallNotifications(@NonNull Context context) { - NotificationManagerUtils.cancelAllInGroup(context, GROUP_KEY); - } - - public static void cancelSingleMissedCallNotification( - @NonNull Context context, @Nullable Uri callUri) { - if (callUri == null) { - LogUtil.e( - "MissedCallNotifier.cancelSingleMissedCallNotification", - "unable to cancel notification, uri is null"); - return; - } - // This will also dismiss the group summary if there are no more missed call notifications. - DialerNotificationManager.cancel( - context, getNotificationTagForCallUri(callUri), NOTIFICATION_ID); - } - private static String getNotificationTagForCall(@NonNull NewCall call) { - return getNotificationTagForCallUri(call.callsUri); - } - - private static String getNotificationTagForCallUri(@NonNull Uri callUri) { - return NOTIFICATION_TAG_PREFIX + callUri; + return MissedCallNotificationTags.getNotificationTagForCallUri(call.callsUri); } @WorkerThread @@ -324,7 +299,7 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { DialerNotificationManager.notify( context, getNotificationTagForCall(call), - NOTIFICATION_ID, + MissedCallConstants.NOTIFICATION_ID, getNotificationForCall(call, note)); return; } @@ -408,7 +383,7 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { private Notification.Builder createNotificationBuilder() { return new Notification.Builder(context) - .setGroup(GROUP_KEY) + .setGroup(MissedCallConstants.GROUP_KEY) .setSmallIcon(android.R.drawable.stat_notify_missed_call) .setColor(context.getResources().getColor(R.color.dialer_theme_color, null)) .setAutoCancel(true) @@ -437,7 +412,7 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { public void callBackFromMissedCall(String number, Uri callUri) { closeSystemDialogs(context); CallLogNotificationsQueryHelper.markSingleMissedCallInCallLogAsRead(context, callUri); - cancelSingleMissedCallNotification(context, callUri); + MissedCallNotificationCanceller.cancelSingle(context, callUri); DialerUtils.startActivityWithErrorToast( context, PreCall.getIntent( @@ -450,7 +425,7 @@ public class MissedCallNotifier implements Worker<Pair<Integer, String>, Void> { public void sendSmsFromMissedCall(String number, Uri callUri) { closeSystemDialogs(context); CallLogNotificationsQueryHelper.markSingleMissedCallInCallLogAsRead(context, callUri); - cancelSingleMissedCallNotification(context, callUri); + MissedCallNotificationCanceller.cancelSingle(context, callUri); DialerUtils.startActivityWithErrorToast( context, IntentUtil.getSendSmsIntent(number).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); } diff --git a/java/com/android/dialer/calllog/CallLogComponent.java b/java/com/android/dialer/calllog/CallLogComponent.java index c7db2a1b8..bb5bfee2a 100644 --- a/java/com/android/dialer/calllog/CallLogComponent.java +++ b/java/com/android/dialer/calllog/CallLogComponent.java @@ -27,6 +27,8 @@ public abstract class CallLogComponent { public abstract RefreshAnnotatedCallLogWorker getRefreshAnnotatedCallLogWorker(); + public abstract ClearMissedCalls getClearMissedCalls(); + public static CallLogComponent get(Context context) { return ((HasComponent) ((HasRootComponent) context.getApplicationContext()).component()) .callLogComponent(); diff --git a/java/com/android/dialer/calllog/ClearMissedCalls.java b/java/com/android/dialer/calllog/ClearMissedCalls.java new file mode 100644 index 000000000..d216e7b88 --- /dev/null +++ b/java/com/android/dialer/calllog/ClearMissedCalls.java @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.calllog; + +import android.annotation.SuppressLint; +import android.content.ContentValues; +import android.content.Context; +import android.net.Uri; +import android.provider.CallLog.Calls; +import android.support.v4.os.UserManagerCompat; +import com.android.dialer.common.LogUtil; +import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor; +import com.android.dialer.common.concurrent.Annotations.Ui; +import com.android.dialer.common.database.Selection; +import com.android.dialer.inject.ApplicationContext; +import com.android.dialer.notification.missedcalls.MissedCallNotificationCanceller; +import com.android.dialer.util.PermissionsUtil; +import com.google.common.collect.ImmutableSet; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import java.util.Collection; +import javax.inject.Inject; + +/** + * Clears missed calls. This includes cancelling notifications and updating the "NEW" status in the + * system call log. + */ +public final class ClearMissedCalls { + + private final Context appContext; + private final ListeningExecutorService backgroundExecutor; + private final ListeningExecutorService uiThreadExecutor; + + @Inject + ClearMissedCalls( + @ApplicationContext Context appContext, + @BackgroundExecutor ListeningExecutorService backgroundExecutor, + @Ui ListeningExecutorService uiThreadExecutor) { + this.appContext = appContext; + this.backgroundExecutor = backgroundExecutor; + this.uiThreadExecutor = uiThreadExecutor; + } + + /** + * Cancels all missed call notifications and marks all "new" missed calls in the system call log + * as "not new". + */ + public ListenableFuture<Void> clearAll() { + ListenableFuture<Void> markNewFuture = markNotNew(ImmutableSet.of()); + ListenableFuture<Void> cancelNotificationsFuture = + uiThreadExecutor.submit( + () -> { + MissedCallNotificationCanceller.cancelAll(appContext); + return null; + }); + + // Note on this usage of whenAllComplete: + // -The returned future completes when all sub-futures complete (whether they fail or not) + // -The returned future fails if any sub-future fails + return Futures.whenAllComplete(markNewFuture, cancelNotificationsFuture) + .call( + () -> { + // Calling get() is necessary to propagate failures. + markNewFuture.get(); + cancelNotificationsFuture.get(); + return null; + }, + MoreExecutors.directExecutor()); + } + + /** + * For the provided set of IDs from the system call log, cancels their missed call notifications + * and marks them "not new". + * + * @param ids IDs from the system call log (see {@link Calls#_ID}}. + */ + public ListenableFuture<Void> clearBySystemCallLogId(Collection<Long> ids) { + ListenableFuture<Void> markNewFuture = markNotNew(ids); + ListenableFuture<Void> cancelNotificationsFuture = + uiThreadExecutor.submit( + () -> { + for (long id : ids) { + Uri callUri = Calls.CONTENT_URI.buildUpon().appendPath(Long.toString(id)).build(); + MissedCallNotificationCanceller.cancelSingle(appContext, callUri); + } + return null; + }); + + // Note on this usage of whenAllComplete: + // -The returned future completes when all sub-futures complete (whether they fail or not) + // -The returned future fails if any sub-future fails + return Futures.whenAllComplete(markNewFuture, cancelNotificationsFuture) + .call( + () -> { + // Calling get() is necessary to propagate failures. + markNewFuture.get(); + cancelNotificationsFuture.get(); + return null; + }, + MoreExecutors.directExecutor()); + } + + /** + * Marks all provided system call log IDs as not new, or if the provided collection is empty, + * marks all calls as not new. + */ + @SuppressLint("MissingPermission") + private ListenableFuture<Void> markNotNew(Collection<Long> ids) { + return backgroundExecutor.submit( + () -> { + if (!UserManagerCompat.isUserUnlocked(appContext)) { + LogUtil.e("ClearMissedCalls.markNotNew", "locked"); + return null; + } + if (!PermissionsUtil.hasCallLogWritePermissions(appContext)) { + LogUtil.e("ClearMissedCalls.markNotNew", "no permission"); + return null; + } + + ContentValues values = new ContentValues(); + values.put(Calls.NEW, 0); + + Selection.Builder selectionBuilder = + Selection.builder() + .and(Selection.column(Calls.NEW).is("=", 1)) + .and(Selection.column(Calls.TYPE).is("=", Calls.MISSED_TYPE)); + if (!ids.isEmpty()) { + selectionBuilder.and(Selection.column(Calls._ID).in(toStrings(ids))); + } + Selection selection = selectionBuilder.build(); + appContext + .getContentResolver() + .update( + Calls.CONTENT_URI, + values, + selection.getSelection(), + selection.getSelectionArgs()); + return null; + }); + } + + private static String[] toStrings(Collection<Long> longs) { + String[] strings = new String[longs.size()]; + int i = 0; + for (long value : longs) { + strings[i++] = Long.toString(value); + } + return strings; + } +} diff --git a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java index 10f75ef07..5e676f072 100644 --- a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java +++ b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java @@ -18,6 +18,7 @@ package com.android.dialer.calllog.ui; import android.database.Cursor; import android.os.Bundle; import android.support.annotation.Nullable; +import android.support.annotation.VisibleForTesting; import android.support.v4.app.Fragment; import android.support.v4.app.LoaderManager.LoaderCallbacks; import android.support.v4.content.Loader; @@ -31,10 +32,14 @@ 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.DefaultFutureCallback; import com.android.dialer.common.concurrent.DialerExecutorComponent; import com.android.dialer.common.concurrent.ThreadUtil; import com.android.dialer.common.concurrent.UiListener; +import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.MoreExecutors; +import java.util.concurrent.TimeUnit; /** The "new" call log fragment implementation, which is built on top of the annotated call log. */ public final class NewCallLogFragment extends Fragment @@ -46,13 +51,19 @@ public final class NewCallLogFragment extends Fragment * 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 static final long REFRESH_ANNOTATED_CALL_LOG_WAIT_MILLIS = 100L; + + @VisibleForTesting + static final long MARK_ALL_CALLS_READ_WAIT_MILLIS = TimeUnit.SECONDS.toMillis(3); private RefreshAnnotatedCallLogWorker refreshAnnotatedCallLogWorker; private UiListener<Void> refreshAnnotatedCallLogListener; private RecyclerView recyclerView; @Nullable private Runnable refreshAnnotatedCallLogRunnable; + private boolean shouldMarkCallsRead = false; + private final Runnable setShouldMarkCallsReadTrue = () -> shouldMarkCallsRead = true; + public NewCallLogFragment() { LogUtil.enterBlock("NewCallLogFragment.NewCallLogFragment"); } @@ -103,6 +114,13 @@ public final class NewCallLogFragment extends Fragment ((NewCallLogAdapter) recyclerView.getAdapter()).clearCache(); recyclerView.getAdapter().notifyDataSetChanged(); } + + // We shouldn't mark the calls as read immediately when the 3 second timer expires because we + // don't want to disrupt the UI; instead we set a bit indicating to mark them read when the user + // leaves the fragment (in onPause). + shouldMarkCallsRead = false; + ThreadUtil.getUiThreadHandler() + .postDelayed(setShouldMarkCallsReadTrue, MARK_ALL_CALLS_READ_WAIT_MILLIS); } @Override @@ -113,9 +131,17 @@ public final class NewCallLogFragment extends Fragment // This is pending work that we don't actually need to follow through with. ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable); + ThreadUtil.getUiThreadHandler().removeCallbacks(setShouldMarkCallsReadTrue); CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework(); callLogFramework.detachUi(); + + if (shouldMarkCallsRead) { + Futures.addCallback( + CallLogComponent.get(getContext()).getClearMissedCalls().clearAll(), + new DefaultFutureCallback<>(), + MoreExecutors.directExecutor()); + } } @Override @@ -159,7 +185,8 @@ public final class NewCallLogFragment extends Fragment throw new RuntimeException(throwable); }); }; - ThreadUtil.getUiThreadHandler().postDelayed(refreshAnnotatedCallLogRunnable, WAIT_MILLIS); + ThreadUtil.getUiThreadHandler() + .postDelayed(refreshAnnotatedCallLogRunnable, REFRESH_ANNOTATED_CALL_LOG_WAIT_MILLIS); } @Override diff --git a/java/com/android/dialer/calllog/ui/menu/Modules.java b/java/com/android/dialer/calllog/ui/menu/Modules.java index d59155810..c85a9fddd 100644 --- a/java/com/android/dialer/calllog/ui/menu/Modules.java +++ b/java/com/android/dialer/calllog/ui/menu/Modules.java @@ -52,15 +52,8 @@ final class Modules { if (canPlaceCalls) { addModuleForVideoOrAudioCall(context, modules, row, normalizedNumber); - - SharedModules.maybeAddModuleForAddingToContacts( - context, - modules, - row.number(), - row.numberAttributes().getName(), - row.numberAttributes().getLookupUri()); - - SharedModules.maybeAddModuleForSendingTextMessage(context, modules, normalizedNumber); + SharedModules.maybeAddModuleForSendingTextMessage( + context, modules, normalizedNumber, row.numberAttributes().getIsBlocked()); } if (!modules.isEmpty()) { @@ -68,10 +61,23 @@ final class Modules { } - // TODO(zachh): Module for blocking/unblocking spam. // TODO(zachh): Module for CallComposer. if (canPlaceCalls) { + SharedModules.maybeAddModuleForAddingToContacts( + context, + modules, + row.number(), + row.numberAttributes().getName(), + row.numberAttributes().getLookupUri(), + row.numberAttributes().getIsBlocked(), + row.numberAttributes().getIsSpam()); + SharedModules.addModulesHandlingBlockedOrSpamNumber( + context, + modules, + normalizedNumber, + row.numberAttributes().getIsBlocked(), + row.numberAttributes().getIsSpam()); SharedModules.maybeAddModuleForCopyingNumber(context, modules, normalizedNumber); } @@ -89,10 +95,23 @@ final class Modules { List<ContactActionModule> modules, CoalescedRow row, String normalizedNumber) { + // If a number is blocked, skip this menu item. + if (row.numberAttributes().getIsBlocked()) { + return; + } + PhoneAccountHandle phoneAccountHandle = TelecomUtil.composePhoneAccountHandle( row.phoneAccountComponentName(), row.phoneAccountId()); + // For a spam number, only audio calls are allowed. + if (row.numberAttributes().getIsSpam()) { + modules.add( + IntentModule.newCallModule( + context, normalizedNumber, phoneAccountHandle, CallInitiationType.Type.CALL_LOG)); + return; + } + if ((row.features() & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO) { // Add an audio call item for video calls. Clicking the top entry on the bottom sheet will // trigger a video call. diff --git a/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java b/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java index 81c05135f..02724e628 100644 --- a/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java +++ b/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java @@ -17,10 +17,15 @@ package com.android.dialer.calllog.ui.menu; import android.content.Context; +import android.provider.CallLog.Calls; import android.view.View; +import com.android.dialer.calllog.CallLogComponent; import com.android.dialer.calllog.model.CoalescedRow; +import com.android.dialer.common.concurrent.DefaultFutureCallback; import com.android.dialer.contactactions.ContactActionBottomSheet; import com.android.dialer.glidephotomanager.GlidePhotoManager; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.MoreExecutors; /** Handles configuration of the bottom sheet menus for call log entries. */ public final class NewCallLogMenu { @@ -28,11 +33,23 @@ public final class NewCallLogMenu { /** Creates and returns the OnClickListener which opens the menu for the provided row. */ public static View.OnClickListener createOnClickListener( Context context, CoalescedRow row, GlidePhotoManager glidePhotoManager) { - return (view) -> - ContactActionBottomSheet.show( - context, - PrimaryAction.fromRow(context, row), - Modules.fromRow(context, row), - glidePhotoManager); + return view -> { + ContactActionBottomSheet.show( + context, + PrimaryAction.fromRow(context, row), + Modules.fromRow(context, row), + glidePhotoManager); + + // If the user opens the bottom sheet for a new call, clear the notifications and make the row + // not bold immediately. To do this, mark all of the calls in group as not new. + if (row.isNew() && row.callType() == Calls.MISSED_TYPE) { + Futures.addCallback( + CallLogComponent.get(context) + .getClearMissedCalls() + .clearBySystemCallLogId(row.coalescedIds().getCoalescedIdList()), + new DefaultFutureCallback<>(), + MoreExecutors.directExecutor()); + } + }; } } diff --git a/java/com/android/dialer/common/concurrent/DefaultFutureCallback.java b/java/com/android/dialer/common/concurrent/DefaultFutureCallback.java new file mode 100644 index 000000000..93ad0faf0 --- /dev/null +++ b/java/com/android/dialer/common/concurrent/DefaultFutureCallback.java @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.dialer.common.concurrent; + +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.MoreExecutors; + +/** + * Returns a {@link FutureCallback} which does nothing on success and crashes the application on + * failure. + * + * <p>You generally shouldn't use this for futures which should be tied to UI, for those use {@link + * UiListener}. + * + * <p>Can be safely used with {@link MoreExecutors#directExecutor()} + */ +public final class DefaultFutureCallback<T> implements FutureCallback<T> { + + @Override + public void onSuccess(T unused) {} + + @Override + public void onFailure(Throwable throwable) { + ThreadUtil.getUiThreadHandler() + .post( + () -> { + throw new RuntimeException(throwable); + }); + } +} diff --git a/java/com/android/dialer/common/concurrent/UiThreadExecutor.java b/java/com/android/dialer/common/concurrent/UiThreadExecutor.java index ec51ed334..8378d69ce 100644 --- a/java/com/android/dialer/common/concurrent/UiThreadExecutor.java +++ b/java/com/android/dialer/common/concurrent/UiThreadExecutor.java @@ -31,7 +31,7 @@ import javax.inject.Inject; public class UiThreadExecutor extends AbstractListeningExecutorService { @Inject - UiThreadExecutor() {} + public UiThreadExecutor() {} @Override public void shutdown() { diff --git a/java/com/android/dialer/contactactions/IntentModule.java b/java/com/android/dialer/contactactions/IntentModule.java index aa7fd25a6..9a345c669 100644 --- a/java/com/android/dialer/contactactions/IntentModule.java +++ b/java/com/android/dialer/contactactions/IntentModule.java @@ -72,7 +72,7 @@ public class IntentModule implements ContactActionModule { context, new CallIntentBuilder(number, initiationType) .setPhoneAccountHandle(phoneAccountHandle)), - R.string.call, + R.string.voice_call, R.drawable.quantum_ic_call_white_24); } diff --git a/java/com/android/dialer/contactactions/SharedModules.java b/java/com/android/dialer/contactactions/SharedModules.java index 7e72863aa..6d97fcb61 100644 --- a/java/com/android/dialer/contactactions/SharedModules.java +++ b/java/com/android/dialer/contactactions/SharedModules.java @@ -20,14 +20,15 @@ import android.content.Context; import android.content.Intent; import android.net.Uri; import android.provider.ContactsContract; -import android.support.annotation.NonNull; import android.support.annotation.Nullable; import android.text.TextUtils; +import android.widget.Toast; import com.android.dialer.DialerPhoneNumber; import com.android.dialer.clipboard.ClipboardUtils; import com.android.dialer.util.IntentUtil; import com.android.dialer.util.UriUtils; import java.util.List; +import java.util.Locale; /** * Modules for the bottom sheet that are shared between NewVoicemailFragment and NewCallLogFragment @@ -37,10 +38,15 @@ public class SharedModules { public static void maybeAddModuleForAddingToContacts( Context context, List<ContactActionModule> modules, - @NonNull DialerPhoneNumber number, - @Nullable String name, - @Nullable String lookupUri) { - // TODO(zachh): Only show this for non-spam/blocked numbers. + DialerPhoneNumber number, + String name, + String lookupUri, + boolean isBlocked, + boolean isSpam) { + // Skip showing the menu item for a spam/blocked number. + if (isBlocked || isSpam) { + return; + } // Skip showing the menu item for existing contacts. if (isExistingContact(lookupUri)) { @@ -83,22 +89,148 @@ public class SharedModules { } public static void maybeAddModuleForSendingTextMessage( - Context context, List<ContactActionModule> modules, String originalNumber) { + Context context, + List<ContactActionModule> modules, + String normalizedNumber, + boolean isBlocked) { + // Don't show the option to send a text message if the number is blocked. + if (isBlocked) { + return; + } + // TODO(zachh): There are some conditions where this module should not be shown; consider - // voicemail, business numbers, blocked numbers, spam numbers, etc. - if (!TextUtils.isEmpty(originalNumber)) { + // voicemail, business numbers, etc. + + if (!TextUtils.isEmpty(normalizedNumber)) { modules.add( new IntentModule( context, - IntentUtil.getSendSmsIntent(originalNumber), + IntentUtil.getSendSmsIntent(normalizedNumber), R.string.send_a_message, R.drawable.quantum_ic_message_vd_theme_24)); } } + public static void addModulesHandlingBlockedOrSpamNumber( + Context context, + List<ContactActionModule> modules, + String normalizedNumber, + boolean isBlocked, + boolean isSpam) { + // For a spam number, add two options: + // (1) "Not spam" and "Block", or + // (2) "Not spam" and "Unblock". + if (isSpam) { + addModuleForMarkingNumberAsNonSpam(context, modules, normalizedNumber); + addModuleForBlockingOrUnblockingNumber(context, modules, normalizedNumber, isBlocked); + return; + } + + // For a blocked non-spam number, add "Unblock" option. + if (isBlocked) { + addModuleForBlockingOrUnblockingNumber(context, modules, normalizedNumber, isBlocked); + return; + } + + // For a number that is neither a spam number nor blocked, add "Block/Report spam" option. + addModuleForBlockingNumberAndOptionallyReportingSpam(context, modules, normalizedNumber); + } + + private static void addModuleForMarkingNumberAsNonSpam( + Context context, List<ContactActionModule> modules, String normalizedNumber) { + modules.add( + new ContactActionModule() { + @Override + public int getStringId() { + return R.string.not_spam; + } + + @Override + public int getDrawableId() { + return R.drawable.quantum_ic_report_off_vd_theme_24; + } + + @Override + public boolean onClick() { + // TODO(a bug): implement this method. + Toast.makeText( + context, + String.format(Locale.ENGLISH, "TODO: Report %s as non-spam", normalizedNumber), + Toast.LENGTH_SHORT) + .show(); + return true; // Close the bottom sheet. + } + }); + } + + private static void addModuleForBlockingOrUnblockingNumber( + Context context, + List<ContactActionModule> modules, + String normalizedNumber, + boolean isBlocked) { + modules.add( + new ContactActionModule() { + @Override + public int getStringId() { + return isBlocked ? R.string.unblock_number : R.string.block_number; + } + + @Override + public int getDrawableId() { + return isBlocked + ? R.drawable.ic_unblock // TODO(a bug): use a vector icon + : R.drawable.quantum_ic_block_vd_theme_24; + } + + @Override + public boolean onClick() { + // TODO(a bug): implement this method. + Toast.makeText( + context, + String.format( + Locale.ENGLISH, + "TODO: " + (isBlocked ? "Unblock " : "Block ") + " number %s.", + normalizedNumber), + Toast.LENGTH_SHORT) + .show(); + return true; // Close the bottom sheet. + } + }); + } + + private static void addModuleForBlockingNumberAndOptionallyReportingSpam( + Context context, List<ContactActionModule> modules, String normalizedNumber) { + modules.add( + new ContactActionModule() { + @Override + public int getStringId() { + return R.string.block_and_optionally_report_spam; + } + + @Override + public int getDrawableId() { + return R.drawable.quantum_ic_block_vd_theme_24; + } + + @Override + public boolean onClick() { + // TODO(a bug): implement this method. + Toast.makeText( + context, + String.format( + Locale.ENGLISH, + "TODO: Block and optionally report as spam %s.", + normalizedNumber), + Toast.LENGTH_SHORT) + .show(); + return true; // Close the bottom sheet. + } + }); + } + public static void maybeAddModuleForCopyingNumber( - Context context, List<ContactActionModule> modules, String originalNumber) { - if (TextUtils.isEmpty(originalNumber)) { + Context context, List<ContactActionModule> modules, String normalizedNumber) { + if (TextUtils.isEmpty(normalizedNumber)) { return; } modules.add( @@ -115,7 +247,7 @@ public class SharedModules { @Override public boolean onClick() { - ClipboardUtils.copyText(context, null, originalNumber, true); + ClipboardUtils.copyText(context, null, normalizedNumber, true); return false; } }); diff --git a/java/com/android/dialer/contactactions/res/drawable-xxxhdpi/ic_unblock.png b/java/com/android/dialer/contactactions/res/drawable-xxxhdpi/ic_unblock.png Binary files differnew file mode 100644 index 000000000..01551e2fc --- /dev/null +++ b/java/com/android/dialer/contactactions/res/drawable-xxxhdpi/ic_unblock.png diff --git a/java/com/android/dialer/contactactions/res/values/strings.xml b/java/com/android/dialer/contactactions/res/values/strings.xml index 0e953a56d..4d598a930 100644 --- a/java/com/android/dialer/contactactions/res/values/strings.xml +++ b/java/com/android/dialer/contactactions/res/values/strings.xml @@ -16,13 +16,31 @@ --> <resources> + <!-- Option shown in call log/voicemail menu to make a voice call [CHAR LIMIT=30] --> + <string name="voice_call">Voice call</string> + + <!-- Option shown in a call log/voicemail menu to make a video call [CHAR LIMIT=30] --> + <string name="video_call">Video call</string> + <!-- Option shown in call log menu/voicemail to add the phone number from an entry to an existing contact (also provides option to create a new contact from the number). [CHAR LIMIT=30] --> - <string name="add_to_contacts">Add to contacts</string> + <string name="add_to_contacts">Add contact</string> <!-- Options shown in call log/voicemail menu to send a SMS to the number represented by the call log/voicemailentry. [CHAR LIMIT=30] --> - <string name="send_a_message">Send a message</string> + <string name="send_a_message">Message</string> + + <!-- Options shown in call log/voicemail menu to mark a number as non-spam. [CHAR LIMIT=30] --> + <string name="not_spam">Not spam</string> + + <!-- Options shown in a call log/voicemail menu to block a number. [CHAR LIMIT=30] --> + <string name="block_number">Block</string> + + <!-- Options shown in a call log/voicemail menu to unblock a number. [CHAR LIMIT=30] --> + <string name="unblock_number">Unblock</string> + + <!-- Options shown in a call log/voicemail menu to block a number and/or report it as spam. [CHAR LIMIT=30] --> + <string name="block_and_optionally_report_spam">Block/Report spam</string> <!-- Option displayed in call log/voicemail menu to copy phone number. [CHAR LIMIT=30] --> <string name="copy_number">Copy number</string> diff --git a/java/com/android/dialer/main/impl/NewMainActivityPeer.java b/java/com/android/dialer/main/impl/NewMainActivityPeer.java index 789648928..0a85667a1 100644 --- a/java/com/android/dialer/main/impl/NewMainActivityPeer.java +++ b/java/com/android/dialer/main/impl/NewMainActivityPeer.java @@ -16,16 +16,22 @@ package com.android.dialer.main.impl; +import android.content.Context; import android.content.Intent; import android.os.Bundle; +import android.support.v4.app.Fragment; import android.support.v4.app.FragmentManager; import android.support.v4.app.FragmentTransaction; +import com.android.dialer.calllog.CallLogComponent; import com.android.dialer.calllog.ui.NewCallLogFragment; +import com.android.dialer.common.concurrent.DefaultFutureCallback; import com.android.dialer.main.MainActivityPeer; import com.android.dialer.main.impl.bottomnav.BottomNavBar; import com.android.dialer.main.impl.bottomnav.BottomNavBar.OnBottomNavTabSelectedListener; import com.android.dialer.main.impl.bottomnav.BottomNavBar.TabIndex; import com.android.dialer.voicemail.listui.NewVoicemailFragment; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.MoreExecutors; /** MainActivityPeer that implements the new fragments. */ public class NewMainActivityPeer implements MainActivityPeer { @@ -40,7 +46,8 @@ public class NewMainActivityPeer implements MainActivityPeer { public void onActivityCreate(Bundle saveInstanceState) { mainActivity.setContentView(R.layout.main_activity); MainBottomNavBarBottomNavTabListener bottomNavBarBottomNavTabListener = - new MainBottomNavBarBottomNavTabListener(mainActivity.getSupportFragmentManager()); + new MainBottomNavBarBottomNavTabListener( + mainActivity.getSupportFragmentManager(), mainActivity.getApplicationContext()); BottomNavBar bottomNav = mainActivity.findViewById(R.id.bottom_nav_bar); bottomNav.addOnTabSelectedListener(bottomNavBarBottomNavTabListener); bottomNav.selectTab(TabIndex.SPEED_DIAL); @@ -77,9 +84,12 @@ public class NewMainActivityPeer implements MainActivityPeer { private static final String VOICEMAIL_TAG = "voicemail"; private final FragmentManager supportFragmentManager; + private final Context appContext; - private MainBottomNavBarBottomNavTabListener(FragmentManager supportFragmentManager) { + private MainBottomNavBarBottomNavTabListener( + FragmentManager supportFragmentManager, Context appContext) { this.supportFragmentManager = supportFragmentManager; + this.appContext = appContext; } @Override @@ -126,8 +136,18 @@ public class NewMainActivityPeer implements MainActivityPeer { private void hideAllFragments() { FragmentTransaction supportTransaction = supportFragmentManager.beginTransaction(); - if (supportFragmentManager.findFragmentByTag(CALL_LOG_TAG) != null) { - supportTransaction.hide(supportFragmentManager.findFragmentByTag(CALL_LOG_TAG)); + Fragment callLogFragment = supportFragmentManager.findFragmentByTag(CALL_LOG_TAG); + if (callLogFragment != null) { + if (callLogFragment.isVisible()) { + // If the user taps any bottom nav button and the call log is showing, immediately cancel + // missed calls (unbold them and clear their notifications). + Futures.addCallback( + // TODO(zachh): Use dagger to create Peer and MainBottomNavBarBottomNavTabListener. + CallLogComponent.get(appContext).getClearMissedCalls().clearAll(), + new DefaultFutureCallback<>(), + MoreExecutors.directExecutor()); + } + supportTransaction.hide(callLogFragment); } if (supportFragmentManager.findFragmentByTag(VOICEMAIL_TAG) != null) { supportTransaction.hide(supportFragmentManager.findFragmentByTag(VOICEMAIL_TAG)); diff --git a/java/com/android/dialer/main/impl/bottomnav/BottomNavBar.java b/java/com/android/dialer/main/impl/bottomnav/BottomNavBar.java index a580aee68..2945e39a9 100644 --- a/java/com/android/dialer/main/impl/bottomnav/BottomNavBar.java +++ b/java/com/android/dialer/main/impl/bottomnav/BottomNavBar.java @@ -162,6 +162,7 @@ public final class BottomNavBar extends LinearLayout { } } + @TabIndex public int getSelectedTab() { return selectedTab; } diff --git a/java/com/android/dialer/notification/missedcalls/MissedCallConstants.java b/java/com/android/dialer/notification/missedcalls/MissedCallConstants.java new file mode 100644 index 000000000..8553ea58e --- /dev/null +++ b/java/com/android/dialer/notification/missedcalls/MissedCallConstants.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.notification.missedcalls; + +/** Constants related to missed call notifications. */ +public final class MissedCallConstants { + + /** Prefix used to generate a unique tag for each missed call notification. */ + public static final String NOTIFICATION_TAG_PREFIX = "MissedCall_"; + + /** Common ID for all missed call notifications. */ + public static final int NOTIFICATION_ID = 1; + + /** Tag for the group summary notification. */ + public static final String GROUP_SUMMARY_NOTIFICATION_TAG = "GroupSummary_MissedCall"; + + /** + * Key used to associate all missed call notifications and the summary as belonging to a single + * group. + */ + public static final String GROUP_KEY = "MissedCallGroup"; +} diff --git a/java/com/android/dialer/notification/missedcalls/MissedCallNotificationCanceller.java b/java/com/android/dialer/notification/missedcalls/MissedCallNotificationCanceller.java new file mode 100644 index 000000000..8798c2127 --- /dev/null +++ b/java/com/android/dialer/notification/missedcalls/MissedCallNotificationCanceller.java @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.android.dialer.notification.missedcalls; + +import android.content.Context; +import android.net.Uri; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import com.android.dialer.common.LogUtil; +import com.android.dialer.notification.DialerNotificationManager; +import com.android.dialer.notification.NotificationManagerUtils; + +/** Cancels missed calls notifications. */ +public final class MissedCallNotificationCanceller { + + /** Cancels all missed call notifications. */ + public static void cancelAll(@NonNull Context context) { + NotificationManagerUtils.cancelAllInGroup(context, MissedCallConstants.GROUP_KEY); + } + + /** Cancels a missed call notification for a single call. */ + public static void cancelSingle(@NonNull Context context, @Nullable Uri callUri) { + if (callUri == null) { + LogUtil.e( + "MissedCallNotificationCanceller.cancelSingle", + "unable to cancel notification, uri is null"); + return; + } + // This will also dismiss the group summary if there are no more missed call notifications. + DialerNotificationManager.cancel( + context, + MissedCallNotificationTags.getNotificationTagForCallUri(callUri), + MissedCallConstants.NOTIFICATION_ID); + } +} diff --git a/java/com/android/dialer/notification/missedcalls/MissedCallNotificationTags.java b/java/com/android/dialer/notification/missedcalls/MissedCallNotificationTags.java new file mode 100644 index 000000000..64f28eeec --- /dev/null +++ b/java/com/android/dialer/notification/missedcalls/MissedCallNotificationTags.java @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.notification.missedcalls; + +import android.net.Uri; +import android.support.annotation.NonNull; + +/** Static methods related to missed call notification tags. */ +public final class MissedCallNotificationTags { + + /** Gets the notification tag for a single call. */ + public static String getNotificationTagForCallUri(@NonNull Uri callUri) { + return MissedCallConstants.NOTIFICATION_TAG_PREFIX + callUri; + } +} diff --git a/java/com/android/dialer/searchfragment/common/res/layout/search_contact_row.xml b/java/com/android/dialer/searchfragment/common/res/layout/search_contact_row.xml index 407207a83..9be7fa046 100644 --- a/java/com/android/dialer/searchfragment/common/res/layout/search_contact_row.xml +++ b/java/com/android/dialer/searchfragment/common/res/layout/search_contact_row.xml @@ -65,4 +65,15 @@ android:tint="@color/dialer_secondary_text_color" android:visibility="gone" android:scaleType="center"/> + + <ImageView + android:id="@+id/work_icon" + android:layout_width="@dimen/search_row_height" + android:layout_height="@dimen/search_row_height" + android:layout_alignParentEnd="true" + android:layout_centerVertical="true" + android:padding="@dimen/call_to_action_padding" + android:src="@drawable/ic_work_profile" + android:scaleType="centerInside" + android:visibility="gone"/> </RelativeLayout>
\ No newline at end of file diff --git a/java/com/android/dialer/searchfragment/remote/RemoteContactViewHolder.java b/java/com/android/dialer/searchfragment/remote/RemoteContactViewHolder.java index 9d369003d..4be96fe58 100644 --- a/java/com/android/dialer/searchfragment/remote/RemoteContactViewHolder.java +++ b/java/com/android/dialer/searchfragment/remote/RemoteContactViewHolder.java @@ -26,8 +26,10 @@ import android.provider.ContactsContract.Contacts; import android.support.v7.widget.RecyclerView; import android.text.TextUtils; import android.view.View; +import android.widget.ImageView; import android.widget.QuickContactBadge; import android.widget.TextView; +import com.android.contacts.common.compat.DirectoryCompat; import com.android.dialer.callintent.CallInitiationType; import com.android.dialer.callintent.CallIntentBuilder; import com.android.dialer.contactphoto.ContactPhotoManager; @@ -46,6 +48,7 @@ public final class RemoteContactViewHolder extends RecyclerView.ViewHolder private final TextView nameView; private final TextView numberView; private final QuickContactBadge photo; + private final ImageView workBadge; private String number; @@ -55,6 +58,7 @@ public final class RemoteContactViewHolder extends RecyclerView.ViewHolder photo = view.findViewById(R.id.photo); nameView = view.findViewById(R.id.primary); numberView = view.findViewById(R.id.secondary); + workBadge = view.findViewById(R.id.work_icon); context = view.getContext(); } @@ -74,6 +78,10 @@ public final class RemoteContactViewHolder extends RecyclerView.ViewHolder nameView.setText(QueryBoldingUtil.getNameWithQueryBolded(query, name, context)); numberView.setText(QueryBoldingUtil.getNameWithQueryBolded(query, secondaryInfo, context)); + workBadge.setVisibility( + DirectoryCompat.isOnlyEnterpriseDirectoryId(cursor.getDirectoryId()) + ? View.VISIBLE + : View.GONE); if (shouldShowPhoto(cursor)) { nameView.setVisibility(View.VISIBLE); diff --git a/java/com/android/dialer/searchfragment/remote/RemoteContactsCursor.java b/java/com/android/dialer/searchfragment/remote/RemoteContactsCursor.java index 9510443b9..653c67041 100644 --- a/java/com/android/dialer/searchfragment/remote/RemoteContactsCursor.java +++ b/java/com/android/dialer/searchfragment/remote/RemoteContactsCursor.java @@ -22,6 +22,7 @@ import android.database.MatrixCursor; import android.database.MergeCursor; import android.support.annotation.Nullable; import android.support.annotation.VisibleForTesting; +import com.android.contacts.common.compat.DirectoryCompat; import com.android.dialer.common.Assert; import com.android.dialer.searchfragment.common.SearchCursor; import com.android.dialer.searchfragment.directories.DirectoriesCursorLoader; @@ -101,7 +102,12 @@ public final class RemoteContactsCursor extends MergeCursor implements SearchCur private static MatrixCursor createHeaderCursor(Context context, String name, long id) { MatrixCursor headerCursor = new MatrixCursor(PROJECTION, 1); - headerCursor.addRow(new Object[] {context.getString(R.string.directory, name), id}); + if (DirectoryCompat.isOnlyEnterpriseDirectoryId(id)) { + headerCursor.addRow( + new Object[] {context.getString(R.string.directory_search_label_work), id}); + } else { + headerCursor.addRow(new Object[] {context.getString(R.string.directory, name), id}); + } return headerCursor; } diff --git a/java/com/android/dialer/searchfragment/remote/RemoteContactsCursorLoader.java b/java/com/android/dialer/searchfragment/remote/RemoteContactsCursorLoader.java index 9feeb7e99..cf495e49c 100644 --- a/java/com/android/dialer/searchfragment/remote/RemoteContactsCursorLoader.java +++ b/java/com/android/dialer/searchfragment/remote/RemoteContactsCursorLoader.java @@ -27,6 +27,7 @@ import android.provider.ContactsContract; import android.provider.ContactsContract.CommonDataKinds.Phone; import android.support.annotation.NonNull; import android.support.annotation.VisibleForTesting; +import com.android.contacts.common.compat.DirectoryCompat; import com.android.dialer.searchfragment.common.Projections; import com.android.dialer.searchfragment.directories.DirectoriesCursorLoader.Directory; import java.util.ArrayList; @@ -71,7 +72,14 @@ public final class RemoteContactsCursorLoader extends CursorLoader { Directory directory = directories.get(i); // Filter out local directories - if (!isRemoteDirectory(directory.getId())) { + if (!DirectoryCompat.isRemoteDirectoryId(directory.getId()) + && !DirectoryCompat.isEnterpriseDirectoryId(directory.getId())) { + cursors[i] = null; + continue; + } + + // Filter out invisible directories + if (DirectoryCompat.isInvisibleDirectory(directory.getId())) { cursors[i] = null; continue; } @@ -93,17 +101,6 @@ public final class RemoteContactsCursorLoader extends CursorLoader { return RemoteContactsCursor.newInstance(getContext(), cursors, directories); } - private static boolean isRemoteDirectory(long directoryId) { - return VERSION.SDK_INT >= VERSION_CODES.N - ? ContactsContract.Directory.isRemoteDirectoryId(directoryId) - : (directoryId != ContactsContract.Directory.DEFAULT - && directoryId != ContactsContract.Directory.LOCAL_INVISIBLE - // Directory.ENTERPRISE_DEFAULT is the default work profile directory for locally stored - // contacts - && directoryId != ContactsContract.Directory.ENTERPRISE_DEFAULT - && directoryId != ContactsContract.Directory.ENTERPRISE_LOCAL_INVISIBLE); - } - private MatrixCursor createMatrixCursorFilteringNullNumbers(Cursor cursor) { if (cursor == null) { return null; diff --git a/java/com/android/dialer/simulator/impl/SimulatorSimCallManager.java b/java/com/android/dialer/simulator/impl/SimulatorSimCallManager.java index 00899fd69..f28393c0c 100644 --- a/java/com/android/dialer/simulator/impl/SimulatorSimCallManager.java +++ b/java/com/android/dialer/simulator/impl/SimulatorSimCallManager.java @@ -29,6 +29,7 @@ import android.telecom.TelecomManager; import android.telephony.TelephonyManager; import com.android.dialer.common.Assert; import com.android.dialer.common.LogUtil; +import com.android.dialer.strictmode.StrictModeUtils; import java.util.Arrays; import java.util.List; import java.util.Random; @@ -53,17 +54,23 @@ public class SimulatorSimCallManager { static void register(@NonNull Context context) { LogUtil.enterBlock("SimulatorSimCallManager.register"); Assert.isNotNull(context); - TelecomManager telecomManager = context.getSystemService(TelecomManager.class); - telecomManager.registerPhoneAccount(buildSimCallManagerAccount(context)); - telecomManager.registerPhoneAccount(buildVideoProviderAccount(context)); + StrictModeUtils.bypass( + () -> { + TelecomManager telecomManager = context.getSystemService(TelecomManager.class); + telecomManager.registerPhoneAccount(buildSimCallManagerAccount(context)); + telecomManager.registerPhoneAccount(buildVideoProviderAccount(context)); + }); } static void unregister(@NonNull Context context) { LogUtil.enterBlock("SimulatorSimCallManager.unregister"); Assert.isNotNull(context); - TelecomManager telecomManager = context.getSystemService(TelecomManager.class); - telecomManager.unregisterPhoneAccount(getSimCallManagerHandle(context)); - telecomManager.unregisterPhoneAccount(getVideoProviderHandle(context)); + StrictModeUtils.bypass( + () -> { + TelecomManager telecomManager = context.getSystemService(TelecomManager.class); + telecomManager.unregisterPhoneAccount(getSimCallManagerHandle(context)); + telecomManager.unregisterPhoneAccount(getVideoProviderHandle(context)); + }); } @NonNull diff --git a/java/com/android/dialer/theme/res/values/strings.xml b/java/com/android/dialer/theme/res/values/strings.xml index 74cabadf7..a14693f51 100644 --- a/java/com/android/dialer/theme/res/values/strings.xml +++ b/java/com/android/dialer/theme/res/values/strings.xml @@ -30,9 +30,6 @@ used in the Launcher icon. --> <string name="launcherActivityLabel">Phone</string> - <!-- text on a button, Video call, as in to place a video call. --> - <string name="video_call">Video call</string> - <!-- Label shown on the 'positive' button for the dialog. Indicates that the call will proceed --> <string name="call">Call</string> </resources> diff --git a/java/com/android/dialer/voicemail/listui/menu/Modules.java b/java/com/android/dialer/voicemail/listui/menu/Modules.java index 665031a1f..7254ad651 100644 --- a/java/com/android/dialer/voicemail/listui/menu/Modules.java +++ b/java/com/android/dialer/voicemail/listui/menu/Modules.java @@ -41,16 +41,25 @@ final class Modules { modules, voicemailEntry.number(), voicemailEntry.numberAttributes().getName(), - voicemailEntry.numberAttributes().getLookupUri()); + voicemailEntry.numberAttributes().getLookupUri(), + voicemailEntry.numberAttributes().getIsBlocked(), + voicemailEntry.numberAttributes().getIsSpam()); String normalizedNumber = voicemailEntry.number().getNormalizedNumber(); - SharedModules.maybeAddModuleForSendingTextMessage(context, modules, normalizedNumber); + SharedModules.maybeAddModuleForSendingTextMessage( + context, modules, normalizedNumber, voicemailEntry.numberAttributes().getIsBlocked()); if (!modules.isEmpty()) { modules.add(new DividerModule()); } - // TODO(zachh): Module for blocking/unblocking spam. + SharedModules.addModulesHandlingBlockedOrSpamNumber( + context, + modules, + normalizedNumber, + voicemailEntry.numberAttributes().getIsBlocked(), + voicemailEntry.numberAttributes().getIsSpam()); + // TODO(zachh): Module for CallComposer. SharedModules.maybeAddModuleForCopyingNumber(context, modules, normalizedNumber); |