Merge "[Call Screening]Binding to call screening apps"
diff --git a/src/com/android/server/telecom/CallsManager.java b/src/com/android/server/telecom/CallsManager.java
index 5635699..d99a51a 100644
--- a/src/com/android/server/telecom/CallsManager.java
+++ b/src/com/android/server/telecom/CallsManager.java
@@ -73,7 +73,7 @@
import com.android.server.telecom.callfiltering.BlockCheckerAdapter;
import com.android.server.telecom.callfiltering.CallFilterResultCallback;
import com.android.server.telecom.callfiltering.CallFilteringResult;
-import com.android.server.telecom.callfiltering.CallScreeningServiceFilter;
+import com.android.server.telecom.callfiltering.CallScreeningServiceController;
import com.android.server.telecom.callfiltering.DirectToVoicemailCallFilter;
import com.android.server.telecom.callfiltering.IncomingCallFilter;
import com.android.server.telecom.components.ErrorDialogActivity;
@@ -568,9 +568,9 @@
filters.add(new DirectToVoicemailCallFilter(mCallerInfoLookupHelper));
filters.add(new AsyncBlockCheckFilter(mContext, new BlockCheckerAdapter(),
mCallerInfoLookupHelper, null));
- filters.add(new CallScreeningServiceFilter(mContext, this, mPhoneAccountRegistrar,
- mDefaultDialerCache, new ParcelableCallUtils.Converter(), mLock,
- new TelecomServiceImpl.SettingsSecureAdapterImpl()));
+ filters.add(new CallScreeningServiceController(mContext, this, mPhoneAccountRegistrar,
+ new ParcelableCallUtils.Converter(), mLock,
+ new TelecomServiceImpl.SettingsSecureAdapterImpl(), mCallerInfoLookupHelper));
new IncomingCallFilter(mContext, this, incomingCall, mLock,
mTimeoutsAdapter, filters).performFiltering();
}
diff --git a/src/com/android/server/telecom/LogUtils.java b/src/com/android/server/telecom/LogUtils.java
index 9015f8a..0ebbd2b 100644
--- a/src/com/android/server/telecom/LogUtils.java
+++ b/src/com/android/server/telecom/LogUtils.java
@@ -108,6 +108,8 @@
public static final String BIND_SCREENING = "BIND_SCREENING";
public static final String SCREENING_BOUND = "SCREENING_BOUND";
public static final String SCREENING_SENT = "SCREENING_SENT";
+ public static final String CONTROLLER_SCREENING_COMPLETED =
+ "CONTROLLER_SCREENING_COMPLETED";
public static final String SCREENING_COMPLETED = "SCREENING_COMPLETED";
public static final String BLOCK_CHECK_INITIATED = "BLOCK_CHECK_INITIATED";
public static final String BLOCK_CHECK_FINISHED = "BLOCK_CHECK_FINISHED";
diff --git a/src/com/android/server/telecom/callfiltering/CallScreeningServiceController.java b/src/com/android/server/telecom/callfiltering/CallScreeningServiceController.java
new file mode 100644
index 0000000..40bf398
--- /dev/null
+++ b/src/com/android/server/telecom/callfiltering/CallScreeningServiceController.java
@@ -0,0 +1,264 @@
+/*
+ * 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.server.telecom.callfiltering;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.PersistableBundle;
+import android.os.UserHandle;
+import android.provider.CallLog;
+import android.provider.Settings;
+import android.telecom.Log;
+import android.telecom.Logging.Runnable;
+import android.telecom.TelecomManager;
+import android.telephony.CarrierConfigManager;
+import android.text.TextUtils;
+
+import com.android.internal.telephony.CallerInfo;
+import com.android.server.telecom.Call;
+import com.android.server.telecom.CallerInfoLookupHelper;
+import com.android.server.telecom.CallsManager;
+import com.android.server.telecom.LogUtils;
+import com.android.server.telecom.ParcelableCallUtils;
+import com.android.server.telecom.PhoneAccountRegistrar;
+import com.android.server.telecom.TelecomServiceImpl;
+import com.android.server.telecom.TelecomSystem;
+
+/**
+ * This class supports binding to the various {@link android.telecom.CallScreeningService}:
+ * carrier, default dialer and user chosen. Carrier's CallScreeningService implementation will be
+ * bound first, and then default dialer's and user chosen's. If Carrier's CallScreeningService
+ * blocks a call, no further CallScreeningService after it will be bound.
+ */
+public class CallScreeningServiceController implements IncomingCallFilter.CallFilter,
+ CallScreeningServiceFilter.CallScreeningFilterResultCallback {
+
+ private final Context mContext;
+ private final CallsManager mCallsManager;
+ private final PhoneAccountRegistrar mPhoneAccountRegistrar;
+ private final ParcelableCallUtils.Converter mParcelableCallUtilsConverter;
+ private final TelecomSystem.SyncRoot mTelecomLock;
+ private final TelecomServiceImpl.SettingsSecureAdapter mSettingsSecureAdapter;
+ private final CallerInfoLookupHelper mCallerInfoLookupHelper;
+
+ private final int CARRIER_CALL_FILTERING_TIMED_OUT = 2000; // 2 seconds
+ private final int CALL_FILTERING_TIMED_OUT = 4500; // 4.5 seconds
+
+ private final Handler mHandler = new Handler(Looper.getMainLooper());
+
+ private Call mCall;
+ private CallFilterResultCallback mCallback;
+
+ private CallFilteringResult mResult = new CallFilteringResult(
+ true, // shouldAllowCall
+ false, // shouldReject
+ true, // shouldAddToCallLog
+ true // shouldShowNotification
+ );
+
+ private boolean mIsFinished;
+ private boolean mIsCarrierFinished;
+ private boolean mIsDefaultDialerFinished;
+ private boolean mIsUserChosenFinished;
+
+ public CallScreeningServiceController(
+ Context context,
+ CallsManager callsManager,
+ PhoneAccountRegistrar phoneAccountRegistrar,
+ ParcelableCallUtils.Converter parcelableCallUtilsConverter,
+ TelecomSystem.SyncRoot lock,
+ TelecomServiceImpl.SettingsSecureAdapter settingsSecureAdapter,
+ CallerInfoLookupHelper callerInfoLookupHelper) {
+ mContext = context;
+ mCallsManager = callsManager;
+ mPhoneAccountRegistrar = phoneAccountRegistrar;
+ mParcelableCallUtilsConverter = parcelableCallUtilsConverter;
+ mTelecomLock = lock;
+ mSettingsSecureAdapter = settingsSecureAdapter;
+ mCallerInfoLookupHelper = callerInfoLookupHelper;
+ }
+
+ @Override
+ public void startFilterLookup(Call call, CallFilterResultCallback callBack) {
+ mCall = call;
+ mCallback = callBack;
+ mIsFinished = false;
+ mIsCarrierFinished = false;
+ mIsDefaultDialerFinished = false;
+ mIsUserChosenFinished = false;
+
+ bindCarrierService();
+
+ // Call screening filtering timed out
+ mHandler.postDelayed(new Runnable("ICF.pFTO", mTelecomLock) {
+ @Override
+ public void loggedRun() {
+ if (!mIsFinished) {
+ Log.i(CallScreeningServiceController.this, "Call screening has timed out.");
+ finishCallScreening();
+ }
+ }
+ }.prepare(), CALL_FILTERING_TIMED_OUT);
+ }
+
+ @Override
+ public void onCallScreeningFilterComplete(Call call, CallFilteringResult result, String
+ packageName) {
+ synchronized (mTelecomLock) {
+ mResult = result.combine(mResult);
+ if (!TextUtils.isEmpty(packageName) && packageName.equals(getCarrierPackageName())) {
+ mIsCarrierFinished = true;
+ if (result.mCallBlockReason == CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE) {
+ finishCallScreening();
+ } else {
+ checkContactExistsAndBindService();
+ }
+ } else if (!TextUtils.isEmpty(packageName) &&
+ packageName.equals(getDefaultDialerPackageName())) {
+ mIsDefaultDialerFinished = true;
+ if (result.mCallBlockReason == CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE ||
+ mIsUserChosenFinished) {
+ finishCallScreening();
+ }
+ } else if (!TextUtils.isEmpty(packageName) &&
+ packageName.equals(getUserChosenPackageName())) {
+ mIsUserChosenFinished = true;
+ if (mIsDefaultDialerFinished) {
+ finishCallScreening();
+ }
+ }
+ }
+ }
+
+ private void bindCarrierService() {
+ String carrierPackageName = getCarrierPackageName();
+ if (TextUtils.isEmpty(carrierPackageName)) {
+ mIsCarrierFinished = true;
+ bindDefaultDialerAndUserChosenService();
+ } else {
+ createCallScreeningServiceFilter().startCallScreeningFilter(mCall, this,
+ carrierPackageName);
+ }
+
+ // Carrier filtering timed out
+ mHandler.postDelayed(new Runnable("ICF.pFTO", mTelecomLock) {
+ @Override
+ public void loggedRun() {
+ if (!mIsCarrierFinished) {
+ mIsCarrierFinished = true;
+ checkContactExistsAndBindService();
+ }
+ }
+ }.prepare(), CARRIER_CALL_FILTERING_TIMED_OUT);
+ }
+
+ private void bindDefaultDialerAndUserChosenService() {
+ if (mIsCarrierFinished) {
+ String dialerPackageName = getDefaultDialerPackageName();
+ if (TextUtils.isEmpty(dialerPackageName)) {
+ mIsDefaultDialerFinished = true;
+ } else {
+ createCallScreeningServiceFilter().startCallScreeningFilter(mCall,
+ CallScreeningServiceController.this, dialerPackageName);
+ }
+
+ String userChosenPackageName = getUserChosenPackageName();
+ if (TextUtils.isEmpty(userChosenPackageName)) {
+ mIsUserChosenFinished = true;
+ } else {
+ createCallScreeningServiceFilter().startCallScreeningFilter(mCall,
+ CallScreeningServiceController.this, userChosenPackageName);
+ }
+
+ if (mIsDefaultDialerFinished && mIsUserChosenFinished) {
+ finishCallScreening();
+ }
+ }
+ }
+
+ private CallScreeningServiceFilter createCallScreeningServiceFilter() {
+ return new CallScreeningServiceFilter(
+ mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar,
+ mParcelableCallUtilsConverter,
+ mTelecomLock,
+ mSettingsSecureAdapter);
+ }
+
+ private void checkContactExistsAndBindService() {
+ mCallerInfoLookupHelper.startLookup(mCall.getHandle(),
+ new CallerInfoLookupHelper.OnQueryCompleteListener() {
+ @Override
+ public void onCallerInfoQueryComplete(Uri handle, CallerInfo info) {
+ boolean contactExists = info != null && info.contactExists;
+ Log.i(CallScreeningServiceController.this, "Contact exists: " +
+ contactExists);
+ if (!contactExists) {
+ bindDefaultDialerAndUserChosenService();
+ } else {
+ finishCallScreening();
+ }
+ }
+
+ @Override
+ public void onContactPhotoQueryComplete(Uri handle, CallerInfo
+ info) {
+ // ignore
+ }
+ });
+ }
+
+ private void finishCallScreening() {
+ Log.addEvent(mCall, LogUtils.Events.CONTROLLER_SCREENING_COMPLETED, mResult);
+ mCallback.onCallFilteringComplete(mCall, mResult);
+ mIsFinished = true;
+ }
+
+ private String getCarrierPackageName() {
+ ComponentName componentName = null;
+ CarrierConfigManager configManager = (CarrierConfigManager) mContext.getSystemService
+ (Context.CARRIER_CONFIG_SERVICE);
+ PersistableBundle configBundle = configManager.getConfig();
+ if (configBundle != null) {
+ componentName = ComponentName.unflattenFromString(configBundle.getString
+ (CarrierConfigManager.KEY_CARRIER_CALL_SCREENING_APP_STRING));
+ }
+
+ return componentName != null ? componentName.getPackageName() : null;
+ }
+
+ private String getDefaultDialerPackageName() {
+ return TelecomManager.from(mContext).getDefaultDialerPackage();
+ }
+
+ private String getUserChosenPackageName() {
+ ComponentName componentName = null;
+ String defaultCallScreeningApplication = mSettingsSecureAdapter.getStringForUser(mContext
+ .getContentResolver(), Settings.Secure.CALL_SCREENING_DEFAULT_COMPONENT,
+ UserHandle.USER_CURRENT);
+
+ if (!TextUtils.isEmpty(defaultCallScreeningApplication)) {
+ componentName = ComponentName.unflattenFromString(defaultCallScreeningApplication);
+ }
+
+ return componentName != null ? componentName.getPackageName() : null;
+ }
+}
diff --git a/src/com/android/server/telecom/callfiltering/CallScreeningServiceFilter.java b/src/com/android/server/telecom/callfiltering/CallScreeningServiceFilter.java
index c89a1a4..f0832e6 100644
--- a/src/com/android/server/telecom/callfiltering/CallScreeningServiceFilter.java
+++ b/src/com/android/server/telecom/callfiltering/CallScreeningServiceFilter.java
@@ -39,11 +39,9 @@
import com.android.internal.telecom.ICallScreeningService;
import com.android.server.telecom.Call;
import com.android.server.telecom.CallsManager;
-import com.android.server.telecom.DefaultDialerCache;
import com.android.server.telecom.LogUtils;
import com.android.server.telecom.ParcelableCallUtils;
import com.android.server.telecom.PhoneAccountRegistrar;
-import com.android.server.telecom.TelecomServiceImpl;
import com.android.server.telecom.TelecomServiceImpl.SettingsSecureAdapter;
import com.android.server.telecom.TelecomSystem;
@@ -53,7 +51,13 @@
* Binds to {@link ICallScreeningService} to allow call blocking. A single instance of this class
* handles a single call.
*/
-public class CallScreeningServiceFilter implements IncomingCallFilter.CallFilter {
+public class CallScreeningServiceFilter {
+
+ public interface CallScreeningFilterResultCallback {
+ void onCallScreeningFilterComplete(Call call, CallFilteringResult result, String
+ packageName);
+ }
+
private class CallScreeningServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName componentName, IBinder service) {
@@ -121,19 +125,19 @@
try {
synchronized (mTelecomLock) {
boolean isServiceRequestingLogging = isLoggable(componentName,
- shouldAddToCallLog);
+ shouldAddToCallLog);
Log.i(this, "disallowCall(%s), shouldReject: %b, shouldAddToCallLog: %b, "
- + "shouldShowNotification: %b", callId, shouldReject,
- isServiceRequestingLogging, shouldShowNotification);
+ + "shouldShowNotification: %b", callId, shouldReject,
+ isServiceRequestingLogging, shouldShowNotification);
if (mCall != null && mCall.getId().equals(callId)) {
mResult = new CallFilteringResult(
- false, // shouldAllowCall
- shouldReject, //shouldReject
- isServiceRequestingLogging, //shouldAddToCallLog
- shouldShowNotification, // shouldShowNotification
- CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
- componentName.getPackageName(), //callScreeningAppName
- componentName.flattenToString() //callScreeningComponentName
+ false, // shouldAllowCall
+ shouldReject, //shouldReject
+ isServiceRequestingLogging, //shouldAddToCallLog
+ shouldShowNotification, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
+ componentName.getPackageName(), //callScreeningAppName
+ componentName.flattenToString() //callScreeningComponentName
);
} else {
Log.w(this, "disallowCall, unknown call id: %s", callId);
@@ -150,17 +154,17 @@
private final Context mContext;
private final PhoneAccountRegistrar mPhoneAccountRegistrar;
private final CallsManager mCallsManager;
- private final DefaultDialerCache mDefaultDialerCache;
private final ParcelableCallUtils.Converter mParcelableCallUtilsConverter;
private final TelecomSystem.SyncRoot mTelecomLock;
private final SettingsSecureAdapter mSettingsSecureAdapter;
private Call mCall;
- private CallFilterResultCallback mCallback;
+ private CallScreeningFilterResultCallback mCallback;
private ICallScreeningService mService;
private ServiceConnection mConnection;
-
+ private String mPackageName;
private boolean mHasFinished = false;
+
private CallFilteringResult mResult = new CallFilteringResult(
true, // shouldAllowCall
false, //shouldReject
@@ -172,28 +176,28 @@
Context context,
CallsManager callsManager,
PhoneAccountRegistrar phoneAccountRegistrar,
- DefaultDialerCache defaultDialerCache,
ParcelableCallUtils.Converter parcelableCallUtilsConverter,
TelecomSystem.SyncRoot lock,
SettingsSecureAdapter settingsSecureAdapter) {
mContext = context;
mPhoneAccountRegistrar = phoneAccountRegistrar;
mCallsManager = callsManager;
- mDefaultDialerCache = defaultDialerCache;
mParcelableCallUtilsConverter = parcelableCallUtilsConverter;
mTelecomLock = lock;
mSettingsSecureAdapter = settingsSecureAdapter;
}
- @Override
- public void startFilterLookup(Call call, CallFilterResultCallback callback) {
+ public void startCallScreeningFilter(Call call,
+ CallScreeningFilterResultCallback callback,
+ String packageName) {
if (mHasFinished) {
Log.w(this, "Attempting to reuse CallScreeningServiceFilter. Ignoring.");
return;
}
- Log.addEvent(call, LogUtils.Events.SCREENING_SENT);
+ Log.addEvent(call, LogUtils.Events.SCREENING_SENT, packageName);
mCall = call;
mCallback = callback;
+ mPackageName = packageName;
if (!bindService()) {
Log.i(this, "Could not bind to call screening service");
finishCallScreening();
@@ -203,7 +207,7 @@
private void finishCallScreening() {
if (!mHasFinished) {
Log.addEvent(mCall, LogUtils.Events.SCREENING_COMPLETED, mResult);
- mCallback.onCallFilteringComplete(mCall, mResult);
+ mCallback.onCallScreeningFilterComplete(mCall, mResult, mPackageName);
if (mConnection != null) {
// We still need to call unbind even if the service disconnected.
@@ -216,25 +220,23 @@
}
private boolean bindService() {
- String dialerPackage = mDefaultDialerCache
- .getDefaultDialerApplication(UserHandle.USER_CURRENT);
- if (TextUtils.isEmpty(dialerPackage)) {
- Log.i(this, "Default dialer is empty. Not performing call screening.");
+ if (TextUtils.isEmpty(mPackageName)) {
+ Log.i(this, "PackageName is empty. Not performing call screening.");
return false;
}
Intent intent = new Intent(CallScreeningService.SERVICE_INTERFACE)
- .setPackage(dialerPackage);
+ .setPackage(mPackageName);
List<ResolveInfo> entries = mContext.getPackageManager().queryIntentServicesAsUser(
intent, 0, mCallsManager.getCurrentUserHandle().getIdentifier());
if (entries.isEmpty()) {
- Log.i(this, "There are no call screening services installed on this device.");
+ Log.i(this, mPackageName + "is no call screening services installed on this device.");
return false;
}
ResolveInfo entry = entries.get(0);
if (entry.serviceInfo == null) {
- Log.w(this, "The call screening service has invalid service info");
+ Log.w(this, mPackageName + " call screening service has invalid service info");
return false;
}
@@ -290,15 +292,15 @@
private boolean isCarrierCallScreeningApp(ComponentName componentName) {
String carrierCallScreeningApp = null;
CarrierConfigManager configManager = (CarrierConfigManager) mContext
- .getSystemService(Context.CARRIER_CONFIG_SERVICE);
+ .getSystemService(Context.CARRIER_CONFIG_SERVICE);
PersistableBundle configBundle = configManager.getConfig();
if (configBundle != null) {
carrierCallScreeningApp = configBundle
- .getString(CarrierConfigManager.KEY_CARRIER_CALL_SCREENING_APP_STRING);
+ .getString(CarrierConfigManager.KEY_CARRIER_CALL_SCREENING_APP_STRING);
}
if (!TextUtils.isEmpty(carrierCallScreeningApp) && carrierCallScreeningApp
- .equals(componentName.flattenToString())) {
+ .equals(componentName.flattenToString())) {
return true;
}
@@ -309,7 +311,7 @@
String defaultDialer = TelecomManager.from(mContext).getDefaultDialerPackage();
if (!TextUtils.isEmpty(defaultDialer) && defaultDialer
- .equals(componentName.getPackageName())) {
+ .equals(componentName.getPackageName())) {
return true;
}
@@ -318,11 +320,11 @@
private boolean isUserChosenCallScreeningApp(ComponentName componentName) {
String defaultCallScreeningApplication = mSettingsSecureAdapter
- .getStringForUser(mContext.getContentResolver(),
- Settings.Secure.CALL_SCREENING_DEFAULT_COMPONENT, UserHandle.USER_CURRENT);
+ .getStringForUser(mContext.getContentResolver(),
+ Settings.Secure.CALL_SCREENING_DEFAULT_COMPONENT, UserHandle.USER_CURRENT);
if (!TextUtils.isEmpty(defaultCallScreeningApplication) && defaultCallScreeningApplication
- .equals(componentName.flattenToString())) {
+ .equals(componentName.flattenToString())) {
return true;
}
diff --git a/tests/src/com/android/server/telecom/tests/CallScreeningServiceControllerTest.java b/tests/src/com/android/server/telecom/tests/CallScreeningServiceControllerTest.java
new file mode 100644
index 0000000..324375b
--- /dev/null
+++ b/tests/src/com/android/server/telecom/tests/CallScreeningServiceControllerTest.java
@@ -0,0 +1,351 @@
+/*
+ * 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.server.telecom.tests;
+
+import android.Manifest;
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.net.Uri;
+import android.os.PersistableBundle;
+import android.os.UserHandle;
+import android.provider.CallLog;
+import android.telecom.TelecomManager;
+import android.telephony.CarrierConfigManager;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.internal.telephony.CallerInfo;
+import com.android.server.telecom.Call;
+import com.android.server.telecom.CallerInfoLookupHelper;
+import com.android.server.telecom.CallsManager;
+import com.android.server.telecom.ParcelableCallUtils;
+import com.android.server.telecom.PhoneAccountRegistrar;
+import com.android.server.telecom.TelecomServiceImpl;
+import com.android.server.telecom.TelecomSystem;
+import com.android.server.telecom.callfiltering.CallFilterResultCallback;
+import com.android.server.telecom.callfiltering.CallFilteringResult;
+import com.android.server.telecom.callfiltering.CallScreeningServiceController;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+
+import java.util.Collections;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(JUnit4.class)
+public class CallScreeningServiceControllerTest extends TelecomTestCase {
+
+ @Mock Context mContext;
+ @Mock Call mCall;
+ @Mock private CallFilterResultCallback mCallback;
+ @Mock CallsManager mCallsManager;
+ @Mock CarrierConfigManager mCarrierConfigManager;
+ @Mock private TelecomManager mTelecomManager;
+ @Mock PackageManager mPackageManager;
+ @Mock ParcelableCallUtils.Converter mParcelableCallUtilsConverter;
+ @Mock PhoneAccountRegistrar mPhoneAccountRegistrar;
+ @Mock private CallerInfoLookupHelper mCallerInfoLookupHelper;
+
+ private ResolveInfo mResolveInfo;
+ private TelecomServiceImpl.SettingsSecureAdapter mSettingsSecureAdapter =
+ spy(new CallScreeningServiceFilterTest.SettingsSecureAdapterFake());
+ private TelecomSystem.SyncRoot mLock = new TelecomSystem.SyncRoot() { };
+
+ private static final String CALL_ID = "u89prgt9ps78y5";
+ private static final Uri TEST_HANDLE = Uri.parse("tel:1235551234");
+ private static final String DEFAULT_DIALER_PACKAGE = "com.android.dialer";
+ private static final String PKG_NAME = "com.android.services.telecom.tests";
+ private static final String CLS_NAME = "CallScreeningService";
+ private static final ComponentName CARRIER_DEFINED_CALL_SCREENING = new ComponentName(
+ "com.android.carrier", "com.android.carrier.callscreeningserviceimpl");
+ private static final ComponentName DEFAULT_DIALER_CALL_SCREENING = new ComponentName(
+ "com.android.dialer", "com.android.dialer.callscreeningserviceimpl");
+ private static final ComponentName USER_CHOSEN_CALL_SCREENING = new ComponentName(
+ "com.android.userchosen", "com.android.userchosen.callscreeningserviceimpl");
+
+ private static final CallFilteringResult PASS_RESULT = new CallFilteringResult(
+ true, // shouldAllowCall
+ false, // shouldReject
+ true, // shouldAddToCallLog
+ true // shouldShowNotification
+ );
+
+ public static class SettingsSecureAdapterFake implements
+ TelecomServiceImpl.SettingsSecureAdapter {
+ @Override
+ public void putStringForUser(ContentResolver resolver, String name, String value,
+ int userHandle) {
+
+ }
+
+ @Override
+ public String getStringForUser(ContentResolver resolver, String name, int userHandle) {
+ return USER_CHOSEN_CALL_SCREENING.flattenToString();
+ }
+ }
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ when(mCallsManager.getCurrentUserHandle()).thenReturn(UserHandle.CURRENT);
+ when(mContext.getPackageManager()).thenReturn(mPackageManager);
+ when(mCall.getId()).thenReturn(CALL_ID);
+
+ setCarrierDefinedCallScreeningApplication();
+ when(TelecomManager.from(mContext)).thenReturn(mTelecomManager);
+ when(mTelecomManager.getDefaultDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE);
+
+ mResolveInfo = new ResolveInfo() {{
+ serviceInfo = new ServiceInfo();
+ serviceInfo.packageName = PKG_NAME;
+ serviceInfo.name = CLS_NAME;
+ serviceInfo.permission = Manifest.permission.BIND_SCREENING_SERVICE;
+ }};
+
+ when(mPackageManager.queryIntentServicesAsUser(nullable(Intent.class), anyInt(), anyInt()))
+ .thenReturn(Collections.singletonList(mResolveInfo));
+ when(mParcelableCallUtilsConverter.toParcelableCall(
+ eq(mCall), anyBoolean(), eq(mPhoneAccountRegistrar))).thenReturn(null);
+ when(mContext.bindServiceAsUser(nullable(Intent.class), nullable(ServiceConnection.class),
+ anyInt(), eq(UserHandle.CURRENT))).thenReturn(true);
+ when(mCall.getHandle()).thenReturn(TEST_HANDLE);
+ }
+
+ @SmallTest
+ @Test
+ public void testAllAllowCall() {
+ CallScreeningServiceController controller = new CallScreeningServiceController(mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar, mParcelableCallUtilsConverter, mLock,
+ mSettingsSecureAdapter, mCallerInfoLookupHelper);
+
+ controller.startFilterLookup(mCall, mCallback);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName());
+
+ CallerInfoLookupHelper.OnQueryCompleteListener queryListener = verifyLookupStart();
+ CallerInfo callerInfo = new CallerInfo();
+ callerInfo.contactExists = false;
+ queryListener.onCallerInfoQueryComplete(TEST_HANDLE, callerInfo);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ DEFAULT_DIALER_CALL_SCREENING.getPackageName());
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT, USER_CHOSEN_CALL_SCREENING
+ .getPackageName());
+
+ verify(mContext, times(3)).bindServiceAsUser(any(Intent.class), any(ServiceConnection
+ .class),
+ eq(Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE),
+ eq(UserHandle.CURRENT));
+
+ verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ }
+
+ @SmallTest
+ @Test
+ public void testCarrierAllowCallAndContactExists() {
+ CallScreeningServiceController controller = new CallScreeningServiceController(mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar, mParcelableCallUtilsConverter, mLock,
+ mSettingsSecureAdapter, mCallerInfoLookupHelper);
+
+ controller.startFilterLookup(mCall, mCallback);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName());
+
+ CallerInfoLookupHelper.OnQueryCompleteListener queryListener = verifyLookupStart();
+ CallerInfo callerInfo = new CallerInfo();
+ callerInfo.contactExists = true;
+ queryListener.onCallerInfoQueryComplete(TEST_HANDLE, callerInfo);
+
+ verify(mContext, times(1)).bindServiceAsUser(any(Intent.class), any(ServiceConnection
+ .class),
+ eq(Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE),
+ eq(UserHandle.CURRENT));
+
+ verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ }
+
+ @SmallTest
+ @Test
+ public void testCarrierCallScreeningRejectCall() {
+ CallScreeningServiceController controller = new CallScreeningServiceController(mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar, mParcelableCallUtilsConverter, mLock,
+ mSettingsSecureAdapter, mCallerInfoLookupHelper);
+
+ controller.startFilterLookup(mCall, mCallback);
+
+ controller.onCallScreeningFilterComplete(mCall, new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName(),
+ CARRIER_DEFINED_CALL_SCREENING.flattenToString()
+ ), CARRIER_DEFINED_CALL_SCREENING.getPackageName());
+
+ verify(mContext, times(1)).bindServiceAsUser(any(Intent.class),
+ any(ServiceConnection.class),
+ eq(Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE),
+ eq(UserHandle.CURRENT));
+
+ verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName(), //callScreeningAppName
+ CARRIER_DEFINED_CALL_SCREENING.flattenToString() //callScreeningComponentName
+ )));
+ }
+
+ @SmallTest
+ @Test
+ public void testDefaultDialerRejectCall() {
+ CallScreeningServiceController controller = new CallScreeningServiceController(mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar, mParcelableCallUtilsConverter, mLock,
+ mSettingsSecureAdapter, mCallerInfoLookupHelper);
+
+ controller.startFilterLookup(mCall, mCallback);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName());
+
+ CallerInfoLookupHelper.OnQueryCompleteListener queryListener = verifyLookupStart();
+ CallerInfo callerInfo = new CallerInfo();
+ callerInfo.contactExists = false;
+ queryListener.onCallerInfoQueryComplete(TEST_HANDLE, callerInfo);
+
+ controller.onCallScreeningFilterComplete(mCall, new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE,
+ DEFAULT_DIALER_CALL_SCREENING.getPackageName(),
+ DEFAULT_DIALER_CALL_SCREENING.flattenToString()
+ ), DEFAULT_DIALER_CALL_SCREENING.getPackageName());
+
+ verify(mContext, times(3)).bindServiceAsUser(any(Intent.class),
+ any(ServiceConnection.class),
+ eq(Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE),
+ eq(UserHandle.CURRENT));
+
+ verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
+ DEFAULT_DIALER_CALL_SCREENING.getPackageName(), //callScreeningAppName
+ DEFAULT_DIALER_CALL_SCREENING.flattenToString() //callScreeningComponentName
+ )));
+ }
+
+ @SmallTest
+ @Test
+ public void testUserChosenRejectCall() {
+ CallScreeningServiceController controller = new CallScreeningServiceController(mContext,
+ mCallsManager,
+ mPhoneAccountRegistrar, mParcelableCallUtilsConverter, mLock,
+ mSettingsSecureAdapter, mCallerInfoLookupHelper);
+
+ controller.startFilterLookup(mCall, mCallback);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName());
+
+ CallerInfoLookupHelper.OnQueryCompleteListener queryListener = verifyLookupStart();
+ CallerInfo callerInfo = new CallerInfo();
+ callerInfo.contactExists = false;
+ queryListener.onCallerInfoQueryComplete(TEST_HANDLE, callerInfo);
+
+ controller.onCallScreeningFilterComplete(mCall, PASS_RESULT,
+ DEFAULT_DIALER_CALL_SCREENING.getPackageName());
+ controller.onCallScreeningFilterComplete(mCall, new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE,
+ USER_CHOSEN_CALL_SCREENING.getPackageName(),
+ USER_CHOSEN_CALL_SCREENING.flattenToString()
+ ), USER_CHOSEN_CALL_SCREENING.getPackageName());
+
+ verify(mContext, times(3)).bindServiceAsUser(any(Intent.class),
+ any(ServiceConnection.class),
+ eq(Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE),
+ eq(UserHandle.CURRENT));
+
+ verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ false, // shouldAllowCall
+ true, // shouldReject
+ false, // shouldAddToCallLog
+ true, // shouldShowNotification
+ CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
+ USER_CHOSEN_CALL_SCREENING.getPackageName(), //callScreeningAppName
+ USER_CHOSEN_CALL_SCREENING.flattenToString() //callScreeningComponentName
+ )));
+ }
+
+ private CallerInfoLookupHelper.OnQueryCompleteListener verifyLookupStart() {
+ return verifyLookupStart(TEST_HANDLE);
+ }
+
+ private CallerInfoLookupHelper.OnQueryCompleteListener verifyLookupStart(Uri handle) {
+
+ ArgumentCaptor<CallerInfoLookupHelper.OnQueryCompleteListener> captor =
+ ArgumentCaptor.forClass(CallerInfoLookupHelper.OnQueryCompleteListener.class);
+ verify(mCallerInfoLookupHelper).startLookup(eq(handle), captor.capture());
+ return captor.getValue();
+ }
+
+ private void setCarrierDefinedCallScreeningApplication() {
+ String carrierDefined = CARRIER_DEFINED_CALL_SCREENING.flattenToString();
+ PersistableBundle bundle = new PersistableBundle();
+ bundle.putString(CarrierConfigManager.KEY_CARRIER_CALL_SCREENING_APP_STRING,
+ carrierDefined);
+ when(mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE))
+ .thenReturn(mCarrierConfigManager);
+ when(mCarrierConfigManager.getConfig()).thenReturn(bundle);
+ }
+}
diff --git a/tests/src/com/android/server/telecom/tests/CallScreeningServiceFilterTest.java b/tests/src/com/android/server/telecom/tests/CallScreeningServiceFilterTest.java
index f2530af..fbdd0c0 100644
--- a/tests/src/com/android/server/telecom/tests/CallScreeningServiceFilterTest.java
+++ b/tests/src/com/android/server/telecom/tests/CallScreeningServiceFilterTest.java
@@ -40,11 +40,9 @@
import com.android.internal.telecom.ICallScreeningService;
import com.android.server.telecom.Call;
import com.android.server.telecom.CallsManager;
-import com.android.server.telecom.DefaultDialerCache;
import com.android.server.telecom.ParcelableCallUtils;
import com.android.server.telecom.PhoneAccountRegistrar;
import com.android.server.telecom.TelecomServiceImpl;
-import com.android.server.telecom.callfiltering.CallFilterResultCallback;
import com.android.server.telecom.callfiltering.CallFilteringResult;
import com.android.server.telecom.callfiltering.CallScreeningServiceFilter;
import com.android.server.telecom.TelecomSystem;
@@ -75,12 +73,11 @@
@Mock Context mContext;
@Mock CallsManager mCallsManager;
@Mock PhoneAccountRegistrar mPhoneAccountRegistrar;
- @Mock DefaultDialerCache mDefaultDialerCache;
@Mock ParcelableCallUtils.Converter mParcelableCallUtilsConverter;
private TelecomSystem.SyncRoot mLock = new TelecomSystem.SyncRoot() { };
@Mock Call mCall;
- @Mock CallFilterResultCallback mCallback;
+ @Mock CallScreeningServiceFilter.CallScreeningFilterResultCallback mCallback;
@Mock PackageManager mPackageManager;
@Mock IBinder mBinder;
@@ -144,10 +141,8 @@
}};
mFilter = new CallScreeningServiceFilter(mContext, mCallsManager, mPhoneAccountRegistrar,
- mDefaultDialerCache, mParcelableCallUtilsConverter, mLock, mSettingsSecureAdapter);
+ mParcelableCallUtilsConverter, mLock, mSettingsSecureAdapter);
- when(mDefaultDialerCache.getDefaultDialerApplication(eq(UserHandle.USER_CURRENT)))
- .thenReturn(PKG_NAME);
when(mPackageManager.queryIntentServicesAsUser(nullable(Intent.class), anyInt(), anyInt()))
.thenReturn(Collections.singletonList(mResolveInfo));
when(mParcelableCallUtilsConverter.toParcelableCall(
@@ -158,11 +153,9 @@
@SmallTest
@Test
- public void testNoDefaultDialer() {
- when(mDefaultDialerCache.getDefaultDialerApplication(eq(UserHandle.USER_CURRENT)))
- .thenReturn(null);
- mFilter.startFilterLookup(mCall, mCallback);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ public void testNoPackageName() {
+ mFilter.startCallScreeningFilter(mCall, mCallback, null);
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(null));
}
@SmallTest
@@ -170,24 +163,24 @@
public void testNoResolveEntries() {
when(mPackageManager.queryIntentServicesAsUser(nullable(Intent.class), anyInt(), anyInt()))
.thenReturn(Collections.emptyList());
- mFilter.startFilterLookup(mCall, mCallback);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@Test
public void testBadResolveEntry() {
mResolveInfo.serviceInfo = null;
- mFilter.startFilterLookup(mCall, mCallback);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@Test
public void testPermissionlessFilterService() {
mResolveInfo.serviceInfo.permission = null;
- mFilter.startFilterLookup(mCall, mCallback);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@@ -195,8 +188,8 @@
public void testContextFailToBind() {
when(mContext.bindServiceAsUser(nullable(Intent.class), nullable(ServiceConnection.class),
anyInt(), eq(UserHandle.CURRENT))).thenReturn(false);
- mFilter.startFilterLookup(mCall, mCallback);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@@ -204,31 +197,34 @@
public void testExceptionInScreeningService() throws Exception {
doThrow(new RemoteException()).when(mCallScreeningService).screenCall(
nullable(ICallScreeningAdapter.class), nullable(ParcelableCall.class));
- mFilter.startFilterLookup(mCall, mCallback);
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
ServiceConnection serviceConnection = verifyBindingIntent();
serviceConnection.onServiceConnected(COMPONENT_NAME, mBinder);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@Test
public void testAllowCall() throws Exception {
- mFilter.startFilterLookup(mCall, mCallback);
+ mFilter.startCallScreeningFilter(mCall, mCallback, PKG_NAME);
ServiceConnection serviceConnection = verifyBindingIntent();
serviceConnection.onServiceConnected(COMPONENT_NAME, mBinder);
ICallScreeningAdapter csAdapter = getCallScreeningAdapter();
csAdapter.allowCall(CALL_ID);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(PASS_RESULT));
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(PASS_RESULT), eq(PKG_NAME));
}
@SmallTest
@Test
public void testDisallowCallForCarrierDefined() throws Exception {
+ mResolveInfo.serviceInfo.packageName = CARRIER_DEFINED_CALL_SCREENING.getPackageName();
+ mResolveInfo.serviceInfo.name = CARRIER_DEFINED_CALL_SCREENING.getClassName();
setCarrierDefinedCallScreeningApplication();
when(TelecomManager.from(mContext)).thenReturn(mTelecomManager);
when(mTelecomManager.getDefaultDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE);
- mFilter.startFilterLookup(mCall, mCallback);
+ mFilter.startCallScreeningFilter(mCall, mCallback,
+ CARRIER_DEFINED_CALL_SCREENING.getPackageName());
ServiceConnection serviceConnection = verifyBindingIntent();
serviceConnection.onServiceConnected(COMPONENT_NAME, mBinder);
ICallScreeningAdapter csAdapter = getCallScreeningAdapter();
@@ -238,7 +234,7 @@
true, // shouldShowNotification
CARRIER_DEFINED_CALL_SCREENING
);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(new CallFilteringResult(
false, // shouldAllowCall
true, // shouldReject
false, // shouldAddToCallLog
@@ -246,17 +242,20 @@
CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
CARRIER_DEFINED_CALL_SCREENING.getPackageName(), //callScreeningAppName
CARRIER_DEFINED_CALL_SCREENING.flattenToString() //callScreeningComponentName
- )));
+ )), eq(CARRIER_DEFINED_CALL_SCREENING.getPackageName()));
}
@SmallTest
@Test
public void testDisallowCallForDefaultDialer() throws Exception {
+ mResolveInfo.serviceInfo.packageName = DEFAULT_DIALER_CALL_SCREENING.getPackageName();
+ mResolveInfo.serviceInfo.name = DEFAULT_DIALER_CALL_SCREENING.getClassName();
setCarrierDefinedCallScreeningApplication();
when(TelecomManager.from(mContext)).thenReturn(mTelecomManager);
when(mTelecomManager.getDefaultDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE);
- mFilter.startFilterLookup(mCall, mCallback);
+ mFilter.startCallScreeningFilter(mCall, mCallback,
+ DEFAULT_DIALER_CALL_SCREENING.getPackageName());
ServiceConnection serviceConnection = verifyBindingIntent();
serviceConnection.onServiceConnected(COMPONENT_NAME, mBinder);
ICallScreeningAdapter csAdapter = getCallScreeningAdapter();
@@ -266,7 +265,7 @@
true, // shouldShowNotification
DEFAULT_DIALER_CALL_SCREENING
);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(new CallFilteringResult(
false, // shouldAllowCall
true, // shouldReject
true, // shouldAddToCallLog
@@ -274,17 +273,20 @@
CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
DEFAULT_DIALER_CALL_SCREENING.getPackageName(), //callScreeningAppName
DEFAULT_DIALER_CALL_SCREENING.flattenToString() //callScreeningComponentName
- )));
+ )), eq(DEFAULT_DIALER_CALL_SCREENING.getPackageName()));
}
@SmallTest
@Test
public void testDisallowCallForUserChosen() throws Exception {
+ mResolveInfo.serviceInfo.packageName = USER_CHOSEN_CALL_SCREENING.getPackageName();
+ mResolveInfo.serviceInfo.name = USER_CHOSEN_CALL_SCREENING.getClassName();
setCarrierDefinedCallScreeningApplication();
when(TelecomManager.from(mContext)).thenReturn(mTelecomManager);
when(mTelecomManager.getDefaultDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE);
- mFilter.startFilterLookup(mCall, mCallback);
+ mFilter.startCallScreeningFilter(mCall, mCallback,
+ USER_CHOSEN_CALL_SCREENING.getPackageName());
ServiceConnection serviceConnection = verifyBindingIntent();
serviceConnection.onServiceConnected(COMPONENT_NAME, mBinder);
ICallScreeningAdapter csAdapter = getCallScreeningAdapter();
@@ -294,7 +296,7 @@
true, // shouldShowNotification
USER_CHOSEN_CALL_SCREENING
);
- verify(mCallback).onCallFilteringComplete(eq(mCall), eq(new CallFilteringResult(
+ verify(mCallback).onCallScreeningFilterComplete(eq(mCall), eq(new CallFilteringResult(
false, // shouldAllowCall
true, // shouldReject
true, // shouldAddToCallLog
@@ -302,7 +304,7 @@
CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, //callBlockReason
USER_CHOSEN_CALL_SCREENING.getPackageName(), //callScreeningAppName
USER_CHOSEN_CALL_SCREENING.flattenToString() //callScreeningComponentName
- )));
+ )), eq(USER_CHOSEN_CALL_SCREENING.getPackageName()));
}
private ServiceConnection verifyBindingIntent() {
@@ -315,8 +317,9 @@
Intent capturedIntent = intentCaptor.getValue();
assertEquals(CallScreeningService.SERVICE_INTERFACE, capturedIntent.getAction());
- assertEquals(PKG_NAME, capturedIntent.getPackage());
- assertEquals(COMPONENT_NAME, capturedIntent.getComponent());
+ assertEquals(mResolveInfo.serviceInfo.packageName, capturedIntent.getPackage());
+ assertEquals(new ComponentName(mResolveInfo.serviceInfo.packageName, mResolveInfo
+ .serviceInfo.name), capturedIntent.getComponent());
return serviceCaptor.getValue();
}
@@ -329,7 +332,7 @@
}
private void setCarrierDefinedCallScreeningApplication() {
- String carrierDefined = "com.android.carrier/com.android.carrier.callscreeningserviceimpl";
+ String carrierDefined = CARRIER_DEFINED_CALL_SCREENING.flattenToString();
PersistableBundle bundle = new PersistableBundle();
bundle.putString(CarrierConfigManager.KEY_CARRIER_CALL_SCREENING_APP_STRING,
carrierDefined);