| /* |
| * Copyright (C) 2016 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 android.telecom; |
| |
| import android.Manifest; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.RequiresPermission; |
| import android.annotation.SdkConstant; |
| import android.annotation.SystemApi; |
| import android.app.Service; |
| import android.content.ComponentName; |
| import android.content.Intent; |
| import android.content.pm.ServiceInfo; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.os.RemoteException; |
| |
| import com.android.internal.os.SomeArgs; |
| import com.android.internal.telecom.ICallScreeningAdapter; |
| import com.android.internal.telecom.ICallScreeningService; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.Objects; |
| |
| /** |
| * This service can be implemented by the default dialer (see |
| * {@link TelecomManager#getDefaultDialerPackage()}) or a third party app to allow or disallow |
| * incoming calls before they are shown to a user. A {@link CallScreeningService} can also see |
| * outgoing calls for the purpose of providing caller ID services for those calls. |
| * <p> |
| * Below is an example manifest registration for a {@code CallScreeningService}. |
| * <pre> |
| * {@code |
| * <service android:name="your.package.YourCallScreeningServiceImplementation" |
| * android:permission="android.permission.BIND_SCREENING_SERVICE"> |
| * <intent-filter> |
| * <action android:name="android.telecom.CallScreeningService"/> |
| * </intent-filter> |
| * </service> |
| * } |
| * </pre> |
| * <p> |
| * A CallScreeningService performs two functions: |
| * <ol> |
| * <li>Call blocking/screening - the service can choose which calls will ring on the user's |
| * device, and which will be silently sent to voicemail.</li> |
| * <li>Call identification - services which provide call identification functionality can |
| * display a user-interface of their choosing which contains identifying information for a call. |
| * </li> |
| * </ol> |
| * <p> |
| * <h2>Becoming the CallScreeningService</h2> |
| * Telecom will bind to a single app chosen by the user which implements the |
| * {@link CallScreeningService} API when there are new incoming and outgoing calls. |
| * <p> |
| * The code snippet below illustrates how your app can request that it fills the call screening |
| * role. |
| * <pre> |
| * {@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 |
| * } |
| * } |
| * } |
| * } |
| * </pre> |
| * |
| * <h2>CallScreeningService Lifecycle</h2> |
| * |
| * The framework binds to the {@link CallScreeningService} implemented by the user-chosen app |
| * filling the {@link android.app.role.RoleManager#ROLE_CALL_SCREENING} role when incoming calls are |
| * received (prior to ringing) and when outgoing calls are placed. The platform calls the |
| * {@link #onScreenCall(Call.Details)} method to provide your service with details about the call. |
| * <p> |
| * For incoming calls, the {@link CallScreeningService} must call |
| * {@link #respondToCall(Call.Details, CallResponse)} within 5 seconds of being bound to indicate to |
| * the platform whether the call should be blocked or not. Your app must do this even if it is |
| * primarily performing caller ID operations and not screening calls. It is important to perform |
| * screening operations in a timely matter as the user's device will not begin ringing until the |
| * response is received (or the timeout is hit). A {@link CallScreeningService} may choose to |
| * perform local database lookups to help determine if a call should be screened or not; care should |
| * be taken to ensure the timeout is not repeatedly hit, causing delays in the incoming call flow. |
| * <p> |
| * If your app provides a caller ID experience, it should launch an activity to show the caller ID |
| * information from {@link #onScreenCall(Call.Details)}. |
| */ |
| 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.onScreeningResponse( |
| callDetails.getTelecomCallId(), |
| new ComponentName(getPackageName(), getClass().getName()), |
| null); |
| } |
| } 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; |
| |
| /** |
| * Parcelable version of {@link CallResponse} used to do IPC. |
| * @hide |
| */ |
| public static class ParcelableCallResponse implements Parcelable { |
| 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 final int mCallComposerAttachmentsToShow; |
| |
| private ParcelableCallResponse( |
| boolean shouldDisallowCall, |
| boolean shouldRejectCall, |
| boolean shouldSilenceCall, |
| boolean shouldSkipCallLog, |
| boolean shouldSkipNotification, |
| boolean shouldScreenCallViaAudioProcessing, |
| int callComposerAttachmentsToShow) { |
| mShouldDisallowCall = shouldDisallowCall; |
| mShouldRejectCall = shouldRejectCall; |
| mShouldSilenceCall = shouldSilenceCall; |
| mShouldSkipCallLog = shouldSkipCallLog; |
| mShouldSkipNotification = shouldSkipNotification; |
| mShouldScreenCallViaAudioProcessing = shouldScreenCallViaAudioProcessing; |
| mCallComposerAttachmentsToShow = callComposerAttachmentsToShow; |
| } |
| |
| protected ParcelableCallResponse(Parcel in) { |
| mShouldDisallowCall = in.readBoolean(); |
| mShouldRejectCall = in.readBoolean(); |
| mShouldSilenceCall = in.readBoolean(); |
| mShouldSkipCallLog = in.readBoolean(); |
| mShouldSkipNotification = in.readBoolean(); |
| mShouldScreenCallViaAudioProcessing = in.readBoolean(); |
| mCallComposerAttachmentsToShow = in.readInt(); |
| } |
| |
| public CallResponse toCallResponse() { |
| return new CallResponse.Builder() |
| .setDisallowCall(mShouldDisallowCall) |
| .setRejectCall(mShouldRejectCall) |
| .setSilenceCall(mShouldSilenceCall) |
| .setSkipCallLog(mShouldSkipCallLog) |
| .setSkipNotification(mShouldSkipNotification) |
| .setShouldScreenCallViaAudioProcessing(mShouldScreenCallViaAudioProcessing) |
| .setCallComposerAttachmentsToShow(mCallComposerAttachmentsToShow) |
| .build(); |
| } |
| |
| public boolean shouldDisallowCall() { |
| return mShouldDisallowCall; |
| } |
| |
| public boolean shouldRejectCall() { |
| return mShouldRejectCall; |
| } |
| |
| public boolean shouldSilenceCall() { |
| return mShouldSilenceCall; |
| } |
| |
| public boolean shouldSkipCallLog() { |
| return mShouldSkipCallLog; |
| } |
| |
| public boolean shouldSkipNotification() { |
| return mShouldSkipNotification; |
| } |
| |
| public boolean shouldScreenCallViaAudioProcessing() { |
| return mShouldScreenCallViaAudioProcessing; |
| } |
| |
| public int getCallComposerAttachmentsToShow() { |
| return mCallComposerAttachmentsToShow; |
| } |
| |
| public static final Creator<ParcelableCallResponse> CREATOR = |
| new Creator<ParcelableCallResponse>() { |
| @Override |
| public ParcelableCallResponse createFromParcel(Parcel in) { |
| return new ParcelableCallResponse(in); |
| } |
| |
| @Override |
| public ParcelableCallResponse[] newArray(int size) { |
| return new ParcelableCallResponse[size]; |
| } |
| }; |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| dest.writeBoolean(mShouldDisallowCall); |
| dest.writeBoolean(mShouldRejectCall); |
| dest.writeBoolean(mShouldSilenceCall); |
| dest.writeBoolean(mShouldSkipCallLog); |
| dest.writeBoolean(mShouldSkipNotification); |
| dest.writeBoolean(mShouldScreenCallViaAudioProcessing); |
| dest.writeInt(mCallComposerAttachmentsToShow); |
| } |
| } |
| |
| /** |
| * Information about how to respond to an incoming call. Call screening apps can construct an |
| * instance of this class using {@link CallResponse.Builder}. |
| */ |
| public static class CallResponse { |
| /** |
| * Bit flag indicating whether to show the picture attachment for call composer. |
| * |
| * Used with {@link Builder#setCallComposerAttachmentsToShow(int)}. |
| */ |
| public static final int CALL_COMPOSER_ATTACHMENT_PICTURE = 1; |
| |
| /** |
| * Bit flag indicating whether to show the location attachment for call composer. |
| * |
| * Used with {@link Builder#setCallComposerAttachmentsToShow(int)}. |
| */ |
| public static final int CALL_COMPOSER_ATTACHMENT_LOCATION = 1 << 1; |
| |
| /** |
| * Bit flag indicating whether to show the subject attachment for call composer. |
| * |
| * Used with {@link Builder#setCallComposerAttachmentsToShow(int)}. |
| */ |
| public static final int CALL_COMPOSER_ATTACHMENT_SUBJECT = 1 << 2; |
| |
| /** |
| * Bit flag indicating whether to show the priority attachment for call composer. |
| * |
| * Used with {@link Builder#setCallComposerAttachmentsToShow(int)}. |
| */ |
| public static final int CALL_COMPOSER_ATTACHMENT_PRIORITY = 1 << 3; |
| |
| /** @hide */ |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef(prefix = "CALL_COMPOSER_ATTACHMENT_", flag = true, |
| value = { |
| CALL_COMPOSER_ATTACHMENT_PICTURE, |
| CALL_COMPOSER_ATTACHMENT_LOCATION, |
| CALL_COMPOSER_ATTACHMENT_SUBJECT, |
| CALL_COMPOSER_ATTACHMENT_PRIORITY |
| } |
| ) |
| public @interface CallComposerAttachmentType {} |
| |
| private static final int NUM_CALL_COMPOSER_ATTACHMENT_TYPES = 4; |
| |
| 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 final int mCallComposerAttachmentsToShow; |
| |
| private CallResponse( |
| boolean shouldDisallowCall, |
| boolean shouldRejectCall, |
| boolean shouldSilenceCall, |
| boolean shouldSkipCallLog, |
| boolean shouldSkipNotification, |
| boolean shouldScreenCallViaAudioProcessing, |
| int callComposerAttachmentsToShow) { |
| 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; |
| mCallComposerAttachmentsToShow = callComposerAttachmentsToShow; |
| } |
| |
| /* |
| * @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; |
| } |
| |
| /** |
| * @return A bitmask of call composer attachments that should be shown to the user. |
| */ |
| public @CallComposerAttachmentType int getCallComposerAttachmentsToShow() { |
| return mCallComposerAttachmentsToShow; |
| } |
| |
| /** @hide */ |
| public ParcelableCallResponse toParcelable() { |
| return new ParcelableCallResponse( |
| mShouldDisallowCall, |
| mShouldRejectCall, |
| mShouldSilenceCall, |
| mShouldSkipCallLog, |
| mShouldSkipNotification, |
| mShouldScreenCallViaAudioProcessing, |
| mCallComposerAttachmentsToShow |
| ); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (o == null || getClass() != o.getClass()) return false; |
| CallResponse that = (CallResponse) o; |
| return mShouldDisallowCall == that.mShouldDisallowCall && |
| mShouldRejectCall == that.mShouldRejectCall && |
| mShouldSilenceCall == that.mShouldSilenceCall && |
| mShouldSkipCallLog == that.mShouldSkipCallLog && |
| mShouldSkipNotification == that.mShouldSkipNotification && |
| mShouldScreenCallViaAudioProcessing |
| == that.mShouldScreenCallViaAudioProcessing && |
| mCallComposerAttachmentsToShow == that.mCallComposerAttachmentsToShow; |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(mShouldDisallowCall, mShouldRejectCall, mShouldSilenceCall, |
| mShouldSkipCallLog, mShouldSkipNotification, |
| mShouldScreenCallViaAudioProcessing, |
| mCallComposerAttachmentsToShow); |
| } |
| |
| public static class Builder { |
| private boolean mShouldDisallowCall; |
| private boolean mShouldRejectCall; |
| private boolean mShouldSilenceCall; |
| private boolean mShouldSkipCallLog; |
| private boolean mShouldSkipNotification; |
| private boolean mShouldScreenCallViaAudioProcessing; |
| private int mCallComposerAttachmentsToShow = -1; |
| |
| /** |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * This request will only be honored if the {@link CallScreeningService} shares the same |
| * uid as the system dialer app. Otherwise, the call will go through as usual. |
| * <p> |
| * 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 |
| * <a href="https://developer.android.com/preview/privacy/foreground-service-types"> |
| * the Android Developer Site</a> for more information. |
| * |
| * @param shouldScreenCallViaAudioProcessing Whether to request further call screening. |
| * @hide |
| */ |
| @SystemApi |
| @RequiresPermission(Manifest.permission.CAPTURE_AUDIO_OUTPUT) |
| public @NonNull Builder setShouldScreenCallViaAudioProcessing( |
| boolean shouldScreenCallViaAudioProcessing) { |
| mShouldScreenCallViaAudioProcessing = shouldScreenCallViaAudioProcessing; |
| return this; |
| } |
| |
| /** |
| * Sets the call composer attachments that should be shown to the user. |
| * |
| * Attachments that are not shown will not be passed to the in-call UI responsible for |
| * displaying the call to the user. |
| * |
| * If this method is not called on a {@link Builder}, all attachments will be shown, |
| * except pictures, which will only be shown to users if the call is from a contact. |
| * |
| * Setting attachments to show will have no effect if the call screening service does |
| * not belong to the same package as the system dialer (as returned by |
| * {@link TelecomManager#getSystemDialerPackage()}). |
| * |
| * @param callComposerAttachmentsToShow A bitmask of call composer attachments to show. |
| */ |
| public @NonNull Builder setCallComposerAttachmentsToShow( |
| @CallComposerAttachmentType int callComposerAttachmentsToShow) { |
| // If the argument is less than zero (meaning unset), no-op since the conversion |
| // to/from the parcelable version may call with that value. |
| if (callComposerAttachmentsToShow < 0) { |
| return this; |
| } |
| |
| if ((callComposerAttachmentsToShow |
| & (1 << NUM_CALL_COMPOSER_ATTACHMENT_TYPES)) != 0) { |
| throw new IllegalArgumentException("Attachment types must match the ones" |
| + " defined in CallResponse"); |
| } |
| mCallComposerAttachmentsToShow = callComposerAttachmentsToShow; |
| return this; |
| } |
| |
| public CallResponse build() { |
| return new CallResponse( |
| mShouldDisallowCall, |
| mShouldRejectCall, |
| mShouldSilenceCall, |
| mShouldSkipCallLog, |
| mShouldSkipNotification, |
| mShouldScreenCallViaAudioProcessing, |
| mCallComposerAttachmentsToShow); |
| } |
| } |
| } |
| |
| 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. |
| * <p> |
| * 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}. |
| * <p> |
| * <em>Note:</em> A {@link CallScreeningService} must respond to a call within 5 seconds. After |
| * this time, the framework will unbind from the {@link CallScreeningService} and ignore its |
| * response. |
| * <p> |
| * <em>Note:</em> 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}. |
| * <ul> |
| * <li>{@link Call.Details#getCallDirection()}</li> |
| * <li>{@link Call.Details#getCallerNumberVerificationStatus()}</li> |
| * <li>{@link Call.Details#getConnectTimeMillis()}</li> |
| * <li>{@link Call.Details#getCreationTimeMillis()}</li> |
| * <li>{@link Call.Details#getHandle()}</li> |
| * </ul> |
| * <p> |
| * 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, unless the {@link CallScreeningService} has been granted |
| * {@link Manifest.permission#READ_CONTACTS} permission by the user. For outgoing calls, no |
| * post-dial digits are passed. |
| * <p> |
| * Calls with a {@link Call.Details#getHandlePresentation()} of |
| * {@link TelecomManager#PRESENTATION_RESTRICTED}, {@link TelecomManager#PRESENTATION_UNKNOWN}, |
| * {@link TelecomManager#PRESENTATION_UNAVAILABLE} or |
| * {@link TelecomManager#PRESENTATION_PAYPHONE} presentation are not provided to the |
| * {@link CallScreeningService}. |
| * |
| * @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. |
| * <p> |
| * 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. |
| * <p> |
| * Calls to this method are ignored unless the {@link Call.Details#getCallDirection()} is |
| * {@link Call.Details#DIRECTION_INCOMING}. |
| * <p> |
| * For incoming calls, a {@link CallScreeningService} MUST call this method within 5 seconds of |
| * {@link #onScreenCall(Call.Details)} being invoked by the platform. |
| * <p> |
| * Calls which are blocked/rejected will be logged to the system call log with a call type of |
| * {@link android.provider.CallLog.Calls#BLOCKED_TYPE} and |
| * {@link android.provider.CallLog.Calls#BLOCK_REASON_CALL_SCREENING_SERVICE} block reason. |
| * |
| * @param callDetails The call to allow. |
| * <p> |
| * 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 { |
| mCallScreeningAdapter.onScreeningResponse( |
| callDetails.getTelecomCallId(), |
| new ComponentName(getPackageName(), getClass().getName()), |
| response.toParcelable()); |
| } catch (RemoteException e) { |
| Log.e(this, e, "Got remote exception when returning response"); |
| } |
| } |
| } |