* Below is an example manifest registration for a {@code CallScreeningService}. *
* {@code
*
*
*
*
* }
*
* * A CallScreeningService performs two functions: *
*
* The code snippet below illustrates how your app can request that it fills the call screening * role. *
* {@code
* private static final int REQUEST_ID = 1;
*
* public void requestRole() {
* RoleManager roleManager = (RoleManager) getSystemService(ROLE_SERVICE);
* Intent intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_SCREENING);
* startActivityForResult(intent, REQUEST_ID);
* }
*
* @Override
* public void onActivityResult(int requestCode, int resultCode, Intent data) {
* if (requestCode == REQUEST_ID) {
* if (resultCode == android.app.Activity.RESULT_OK) {
* // Your app is now the call screening app
* } else {
* // Your app is not the call screening app
* }
* }
* }
*
*/
public abstract class CallScreeningService extends Service {
/**
* The {@link Intent} that must be declared as handled by the service.
*/
@SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION)
public static final String SERVICE_INTERFACE = "android.telecom.CallScreeningService";
private static final int MSG_SCREEN_CALL = 1;
private final Handler mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_SCREEN_CALL:
SomeArgs args = (SomeArgs) msg.obj;
try {
mCallScreeningAdapter = (ICallScreeningAdapter) args.arg1;
Call.Details callDetails = Call.Details
.createFromParcelableCall((ParcelableCall) args.arg2);
onScreenCall(callDetails);
if (callDetails.getCallDirection() == Call.Details.DIRECTION_OUTGOING) {
mCallScreeningAdapter.allowCall(callDetails.getTelecomCallId());
}
} catch (RemoteException e) {
Log.w(this, "Exception when screening call: " + e);
} finally {
args.recycle();
}
break;
}
}
};
private final class CallScreeningBinder extends ICallScreeningService.Stub {
@Override
public void screenCall(ICallScreeningAdapter adapter, ParcelableCall call) {
Log.v(this, "screenCall");
SomeArgs args = SomeArgs.obtain();
args.arg1 = adapter;
args.arg2 = call;
mHandler.obtainMessage(MSG_SCREEN_CALL, args).sendToTarget();
}
}
private ICallScreeningAdapter mCallScreeningAdapter;
/*
* Information about how to respond to an incoming call.
*/
public static class CallResponse {
private final boolean mShouldDisallowCall;
private final boolean mShouldRejectCall;
private final boolean mShouldSilenceCall;
private final boolean mShouldSkipCallLog;
private final boolean mShouldSkipNotification;
private final boolean mShouldScreenCallViaAudioProcessing;
private CallResponse(
boolean shouldDisallowCall,
boolean shouldRejectCall,
boolean shouldSilenceCall,
boolean shouldSkipCallLog,
boolean shouldSkipNotification,
boolean shouldScreenCallViaAudioProcessing) {
if (!shouldDisallowCall
&& (shouldRejectCall || shouldSkipCallLog || shouldSkipNotification)) {
throw new IllegalStateException("Invalid response state for allowed call.");
}
if (shouldDisallowCall && shouldScreenCallViaAudioProcessing) {
throw new IllegalStateException("Invalid response state for allowed call.");
}
mShouldDisallowCall = shouldDisallowCall;
mShouldRejectCall = shouldRejectCall;
mShouldSkipCallLog = shouldSkipCallLog;
mShouldSkipNotification = shouldSkipNotification;
mShouldSilenceCall = shouldSilenceCall;
mShouldScreenCallViaAudioProcessing = shouldScreenCallViaAudioProcessing;
}
/*
* @return Whether the incoming call should be blocked.
*/
public boolean getDisallowCall() {
return mShouldDisallowCall;
}
/*
* @return Whether the incoming call should be disconnected as if the user had manually
* rejected it.
*/
public boolean getRejectCall() {
return mShouldRejectCall;
}
/*
* @return Whether the ringtone should be silenced for the incoming call.
*/
public boolean getSilenceCall() {
return mShouldSilenceCall;
}
/*
* @return Whether the incoming call should not be displayed in the call log.
*/
public boolean getSkipCallLog() {
return mShouldSkipCallLog;
}
/*
* @return Whether a missed call notification should not be shown for the incoming call.
*/
public boolean getSkipNotification() {
return mShouldSkipNotification;
}
/**
* @return Whether we should enter the {@link Call#STATE_AUDIO_PROCESSING} state to allow
* for further screening of the call.
* @hide
*/
public boolean getShouldScreenCallViaAudioProcessing() {
return mShouldScreenCallViaAudioProcessing;
}
public static class Builder {
private boolean mShouldDisallowCall;
private boolean mShouldRejectCall;
private boolean mShouldSilenceCall;
private boolean mShouldSkipCallLog;
private boolean mShouldSkipNotification;
private boolean mShouldScreenCallViaAudioProcessing;
/**
* Sets whether the incoming call should be blocked.
*/
public Builder setDisallowCall(boolean shouldDisallowCall) {
mShouldDisallowCall = shouldDisallowCall;
return this;
}
/**
* Sets whether the incoming call should be disconnected as if the user had manually
* rejected it. This property should only be set to true if the call is disallowed.
*/
public Builder setRejectCall(boolean shouldRejectCall) {
mShouldRejectCall = shouldRejectCall;
return this;
}
/**
* Sets whether ringing should be silenced for the incoming call. When set
* to {@code true}, the Telecom framework will not play a ringtone for the call.
* The call will, however, still be sent to the default dialer app if it is not blocked.
* A {@link CallScreeningService} can use this to ensure a potential nuisance call is
* still surfaced to the user, but in a less intrusive manner.
*
* Setting this to true only makes sense when the call has not been disallowed
* using {@link #setDisallowCall(boolean)}.
*/
public @NonNull Builder setSilenceCall(boolean shouldSilenceCall) {
mShouldSilenceCall = shouldSilenceCall;
return this;
}
/**
* Sets whether the incoming call should not be displayed in the call log. This property
* should only be set to true if the call is disallowed.
* * Note: Calls will still be logged with type * {@link android.provider.CallLog.Calls#BLOCKED_TYPE}, regardless of how this property * is set. */ public Builder setSkipCallLog(boolean shouldSkipCallLog) { mShouldSkipCallLog = shouldSkipCallLog; return this; } /** * Sets whether a missed call notification should not be shown for the incoming call. * This property should only be set to true if the call is disallowed. */ public Builder setSkipNotification(boolean shouldSkipNotification) { mShouldSkipNotification = shouldSkipNotification; return this; } /** * Sets whether to request background audio processing so that the in-call service can * screen the call further. If set to {@code true}, {@link #setDisallowCall} should be * called with {@code false}, and all other parameters in this builder will be ignored. *
* This request will only be honored if the {@link CallScreeningService} shares the same * uid as the default dialer app. Otherwise, the call will go through as usual. *
* Apps built with SDK version {@link android.os.Build.VERSION_CODES#R} or later which * are using the microphone as part of audio processing should specify the * foreground service type using the attribute * {@link android.R.attr#foregroundServiceType} in the {@link CallScreeningService} * service element of the app's manifest file. * The {@link ServiceInfo#FOREGROUND_SERVICE_TYPE_MICROPHONE} attribute should be * specified. * @see * * the Android Developer Site for more information. * * @param shouldScreenCallViaAudioProcessing Whether to request further call screening. * @hide */ @SystemApi @TestApi public @NonNull Builder setShouldScreenCallViaAudioProcessing( boolean shouldScreenCallViaAudioProcessing) { mShouldScreenCallViaAudioProcessing = shouldScreenCallViaAudioProcessing; return this; } public CallResponse build() { return new CallResponse( mShouldDisallowCall, mShouldRejectCall, mShouldSilenceCall, mShouldSkipCallLog, mShouldSkipNotification, mShouldScreenCallViaAudioProcessing); } } } public CallScreeningService() { } @Override public IBinder onBind(Intent intent) { Log.v(this, "onBind"); return new CallScreeningBinder(); } @Override public boolean onUnbind(Intent intent) { Log.v(this, "onUnbind"); return false; } /** * Called when a new incoming or outgoing call is added which is not in the user's contact list. *
* A {@link CallScreeningService} must indicate whether an incoming call is allowed or not by * calling * {@link CallScreeningService#respondToCall(Call.Details, CallScreeningService.CallResponse)}. * Your app can tell if a call is an incoming call by checking to see if * {@link Call.Details#getCallDirection()} is {@link Call.Details#DIRECTION_INCOMING}. *
* Note: The {@link Call.Details} instance provided to a call screening service will only have * the following properties set. The rest of the {@link Call.Details} properties will be set to * their default value or {@code null}. *
* Only calls where the {@link Call.Details#getHandle() handle} {@link Uri#getScheme() scheme} * is {@link PhoneAccount#SCHEME_TEL} are passed for call * screening. Further, only calls which are not in the user's contacts are passed for * screening. For outgoing calls, no post-dial digits are passed. * * @param callDetails Information about a new call, see {@link Call.Details}. */ public abstract void onScreenCall(@NonNull Call.Details callDetails); /** * Responds to the given incoming call, either allowing it, silencing it or disallowing it. *
* The {@link CallScreeningService} calls this method to inform the system whether the call * should be silently blocked or not. In the event that it should not be blocked, it may * also be requested to ring silently. *
* Calls to this method are ignored unless the {@link Call.Details#getCallDirection()} is * {@link Call.Details#DIRECTION_INCOMING}. * * @param callDetails The call to allow. *
* Must be the same {@link Call.Details call} which was provided to the * {@link CallScreeningService} via {@link #onScreenCall(Call.Details)}. * @param response The {@link CallScreeningService.CallResponse} which contains information * about how to respond to a call. */ public final void respondToCall(@NonNull Call.Details callDetails, @NonNull CallResponse response) { try { if (response.getDisallowCall()) { mCallScreeningAdapter.disallowCall( callDetails.getTelecomCallId(), response.getRejectCall(), !response.getSkipCallLog(), !response.getSkipNotification(), new ComponentName(getPackageName(), getClass().getName())); } else if (response.getSilenceCall()) { mCallScreeningAdapter.silenceCall(callDetails.getTelecomCallId()); } else if (response.getShouldScreenCallViaAudioProcessing()) { mCallScreeningAdapter.screenCallFurther(callDetails.getTelecomCallId()); } else { mCallScreeningAdapter.allowCall(callDetails.getTelecomCallId()); } } catch (RemoteException e) { } } }