* 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("android.app.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;
onScreenCall(
Call.Details.createFromParcelableCall((ParcelableCall) args.arg2));
} 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 CallResponse(
boolean shouldDisallowCall,
boolean shouldRejectCall,
boolean shouldSilenceCall,
boolean shouldSkipCallLog,
boolean shouldSkipNotification) {
if (!shouldDisallowCall
&& (shouldRejectCall || shouldSkipCallLog || shouldSkipNotification)) {
throw new IllegalStateException("Invalid response state for allowed call.");
}
mShouldDisallowCall = shouldDisallowCall;
mShouldRejectCall = shouldRejectCall;
mShouldSkipCallLog = shouldSkipCallLog;
mShouldSkipNotification = shouldSkipNotification;
mShouldSilenceCall = shouldSilenceCall;
}
/*
* @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;
}
public static class Builder {
private boolean mShouldDisallowCall;
private boolean mShouldRejectCall;
private boolean mShouldSilenceCall;
private boolean mShouldSkipCallLog;
private boolean mShouldSkipNotification;
/**
* 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; } public CallResponse build() { return new CallResponse( mShouldDisallowCall, mShouldRejectCall, mShouldSilenceCall, mShouldSkipCallLog, mShouldSkipNotification); } } } 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 { mCallScreeningAdapter.allowCall(callDetails.getTelecomCallId()); } } catch (RemoteException e) { } } }