android-14.0.0_r21/s

/*
 * 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 android.telecom.cts;

import static android.telecom.cts.TestUtils.shouldTestTelecom;
import static android.telecom.cts.TestUtils.waitOnAllHandlers;

import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;

import android.Manifest;
import android.app.role.RoleManager;
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.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Process;
import android.os.UserHandle;
import android.provider.CallLog;
import android.telecom.Call;
import android.telecom.CallScreeningService;
import android.telecom.TelecomManager;
import android.telecom.cts.screeningtestapp.CallScreeningServiceControl;
import android.telecom.cts.screeningtestapp.CtsCallScreeningService;
import android.telecom.cts.screeningtestapp.ICallScreeningControl;
import android.text.TextUtils;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ThirdPartyCallScreeningServiceTest extends BaseTelecomTestWithMockServices {
    public static final String EXTRA_NETWORK_IDENTIFIED_EMERGENCY_CALL = "identifiedEmergencyCall";
    private static final String TAG = ThirdPartyCallScreeningServiceTest.class.getSimpleName();
    private static final String TEST_APP_NAME = "CTSCSTest";
    private static final String TEST_APP_PACKAGE = "android.telecom.cts.screeningtestapp";
    private static final String TEST_APP_COMPONENT =
            "android.telecom.cts.screeningtestapp/"
                    + "android.telecom.cts.screeningtestapp.CtsCallScreeningService";
    private static final int ASYNC_TIMEOUT = 10000;
    private static final String ROLE_CALL_SCREENING = RoleManager.ROLE_CALL_SCREENING;
    private static final Uri TEST_OUTGOING_NUMBER = Uri.fromParts("tel", "6505551212", null);

    private ICallScreeningControl mCallScreeningControl;
    private RoleManager mRoleManager;
    private String mPreviousCallScreeningPackage;
    private PackageManager mPackageManager;
    private Uri mContactUri;
    private ContentResolver mContentResolver;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        if (!mShouldTestTelecom) {
            return;
        }
        mRoleManager = (RoleManager) mContext.getSystemService(Context.ROLE_SERVICE);
        mPackageManager = mContext.getPackageManager();
        revokeReadContactPermission();
        setupControlBinder();
        setupConnectionService(null, FLAG_REGISTER | FLAG_ENABLE);
        rememberPreviousCallScreeningApp();
        // Ensure CTS app holds the call screening role.
        addRoleHolder(ROLE_CALL_SCREENING,
                CtsCallScreeningService.class.getPackage().getName());
        mContentResolver = getInstrumentation().getTargetContext().getContentResolver();
    }

    @Override
    protected void tearDown() throws Exception {
        if (mShouldTestTelecom) {
            if (mCallScreeningControl != null) {
                mCallScreeningControl.reset();
            }

            // Remove the test app from the screening role.
            removeRoleHolder(ROLE_CALL_SCREENING,
                    CtsCallScreeningService.class.getPackage().getName());

            if (!TextUtils.isEmpty(mPreviousCallScreeningPackage)) {
                addRoleHolder(ROLE_CALL_SCREENING, mPreviousCallScreeningPackage);
            }
        }
        super.tearDown();
    }

    /**
     * Verifies that a {@link android.telecom.CallScreeningService} can reject an incoming call.
     * Ensures that the system logs the blocked call to the call log.
     *
     * @throws Exception
     */
    public void testRejectCall() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        // Tell the test app to block the call.
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);

        addIncomingAndVerifyBlocked(false /* addContact */);
    }

    /**
     * Similar to {@link #testRejectCall()}, except the {@link android.telecom.CallScreeningService}
     * tries to skip logging the call to the call log.  We verify that Telecom still logs the call
     * to the call log, retaining the API behavior documented in
     * {@link android.telecom.CallScreeningService#respondToCall(Call.Details, CallScreeningService.CallResponse)}
     * @throws Exception
     */
    public void testRejectCallAndTryToSkipCallLog() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        // Tell the test app to block the call; also try to skip logging the call.
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                true /* shouldSkipCallLog */, true /* shouldSkipNotification */);

        addIncomingAndVerifyBlocked(false /* addContact */);
    }

    /**
     * Verifies that a {@link android.telecom.CallScreeningService} set the extra to silence a call.
     * @throws Exception
     */
    public void testIncomingCallHasSilenceExtra() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        // Tell the test app to silence the call.
        mCallScreeningControl.setCallResponse(false /* shouldDisallowCall */,
            false /* shouldRejectCall */, true /* shouldSilenceCall */,
            false /* shouldSkipCallLog */, false /* shouldSkipNotification */);

        addIncomingAndVerifyCallExtraForSilence(true);
    }

    /**
     * Verifies that a {@link android.telecom.CallScreeningService} did not set the extra to silence an incoming call.
     * @throws Exception
     */
    public void testIncomingCallDoesNotHaveHaveSilenceExtra() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        // Tell the test app to not silence the call.
        mCallScreeningControl.setCallResponse(false /* shouldDisallowCall */,
                false /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, false /* shouldSkipNotification */);

        addIncomingAndVerifyCallExtraForSilence(false);
    }

    public void testHasPermissionAndNoContactIncoming() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        grantReadContactPermission();
        verifyPermission(true);
        // Tell the test app to block the call.
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);
        addIncomingAndVerifyBlocked(false /* addContact */);
    }

    public void testNoPermissionAndNoContactIncoming() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        verifyPermission(false);
        // Tell the test app to block the call.
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);
        addIncomingAndVerifyBlocked(false /* addContact */);
    }

    public void testHasPermissionAndHasContactIncoming() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        grantReadContactPermission();
        verifyPermission(true);
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);
        addIncomingAndVerifyBlocked(true /* addContact */);
    }

    public void testNoPermissionAndHasContactIncoming() throws Exception {
        if (!shouldTestTelecom(mContext) || !TestUtils.hasTelephonyFeature(mContext)) {
            return;
        }

        verifyPermission(false);
        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);
        addIncomingAndVerifyAllowed(true /* addContact */);
    }

    public void testHasPermissionAndNoContactOutgoing() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        grantReadContactPermission();
        verifyPermission(true);
        placeOutgoingCall(false /* addContact */);
        assertTrue(mCallScreeningControl.waitForBind());
    }

    public void testNoPermissionAndNoContactOutgoing() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        verifyPermission(false);
        placeOutgoingCall(false /* addContact */);
        assertTrue(mCallScreeningControl.waitForBind());
    }

    public void testHasPermissionAndHasContactOutgoing() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        grantReadContactPermission();
        verifyPermission(true);
        placeOutgoingCall(true /* addCountact */);
        assertTrue(mCallScreeningControl.waitForBind());
    }

    public void testNoPermissionAndHasContactOutgoing() throws Exception {
        if (!shouldTestTelecom(mContext) || !TestUtils.hasTelephonyFeature(mContext)) {
            return;
        }

        verifyPermission(false);
        placeOutgoingCall(true /* addCountact */);
        assertFalse(mCallScreeningControl.waitForBind());
    }

    public void testNoPostCallActivityWithoutRole() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        removeRoleHolder(ROLE_CALL_SCREENING, CtsCallScreeningService.class.getPackage().getName());
        addIncomingAndVerifyAllowed(false);
        assertFalse(mCallScreeningControl.waitForActivity());
    }

    public void testAllowCall() throws Exception {
        if (!mShouldTestTelecom) {
            return;
        }

        mCallScreeningControl.setCallResponse(false /* shouldDisallowCall */,
                false /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, false /* shouldSkipNotification */);
        addIncomingAndVerifyAllowed(false /* addContact */);
        assertTrue(mCallScreeningControl.waitForActivity());
    }

    public void testNoPostCallActivityWhenBlocked() throws Exception {
        if (!mShouldTestTelecom) {
            return;
        }

        mCallScreeningControl.setCallResponse(true /* shouldDisallowCall */,
                true /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, true /* shouldSkipNotification */);
        addIncomingAndVerifyBlocked(false /* addContact */);
        assertFalse(mCallScreeningControl.waitForActivity());
    }

    public void testNoPostCallActivityWhenAudioProcessing() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        mCallScreeningControl.setCallResponse(false /* shouldDisallowCall */,
                false /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, false /* shouldSkipNotification */);
        Uri testNumber = createRandomTestNumber();
        Bundle extras = new Bundle();
        extras.putParcelable(TelecomManager.EXTRA_INCOMING_CALL_ADDRESS, testNumber);
        mTelecomManager.addNewIncomingCall(TestUtils.TEST_PHONE_ACCOUNT_HANDLE, extras);

        // Wait until the new incoming call is processed.
        waitOnAllHandlers(getInstrumentation());

        assertEquals(1, mInCallCallbacks.getService().getCallCount());
        Call call = mInCallCallbacks.getService().getLastCall();
        call.enterBackgroundAudioProcessing();

        waitOnAllHandlers(getInstrumentation());
        mInCallCallbacks.getService().disconnectAllCalls();
        assertFalse(mCallScreeningControl.waitForActivity());
    }

    public void testNoPostCallActivityForOutgoingEmergencyCall() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }

        setupForEmergencyCalling(TEST_EMERGENCY_NUMBER);
        Bundle extras = new Bundle();
        extras.putParcelable(TestUtils.EXTRA_PHONE_NUMBER, TEST_EMERGENCY_URI);
        placeAndVerifyCall(extras);

        // Wait until the new incoming call is processed.
        waitOnAllHandlers(getInstrumentation());
        mInCallCallbacks.getService().disconnectAllCalls();
        assertFalse(mCallScreeningControl.waitForActivity());
    }

    public void testNoPostCallActivityForIncomingEmergencyCall() throws Exception {
        if (!shouldTestTelecom(mContext)) {
            return;
        }
        setupForEmergencyCalling(TEST_EMERGENCY_NUMBER);
        mCallScreeningControl.setCallResponse(false /* shouldDisallowCall */,
                false /* shouldRejectCall */, false /* shouldSilenceCall */,
                false /* shouldSkipCallLog */, false /* shouldSkipNotification */);
        Bundle extras = new Bundle();
        extras.putParcelable(TelecomManager.EXTRA_INCOMING_CALL_ADDRESS, TEST_EMERGENCY_URI);
        extras.putBoolean(EXTRA_NETWORK_IDENTIFIED_EMERGENCY_CALL, true);
        mTelecomManager.addNewIncomingCall(TestUtils.TEST_PHONE_ACCOUNT_HANDLE, extras);

        // Wait until the new incoming call is processed.
        waitOnAllHandlers(getInstrumentation());
        mInCallCallbacks.getService().disconnectAllCalls();

        assertFalse(mCallScreeningControl.waitForActivity());
    }

    private void placeOutgoingCall(boolean addContact) throws Exception {
        // Setup content observer to notify us when we call log entry is added.
        CountDownLatch callLogEntryLatch = getCallLogEntryLatch();

        Uri contactUri = null;
        if (addContact) {
            contactUri = TestUtils.insertContact(mContentResolver,
                    TEST_OUTGOING_NUMBER.getSchemeSpecificPart());
        }

        try {
            Bundle extras = new Bundle();
            extras.putParcelable(TestUtils.EXTRA_PHONE_NUMBER, TEST_OUTGOING_NUMBER);
            // Create a new outgoing call.
            placeAndVerifyCall(extras);

            mInCallCallbacks.getService().disconnectAllCalls();
            assertNumCalls(mInCallCallbacks.getService(), 0);

            // Wait for it to log.
            callLogEntryLatch.await(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS);
        } finally {
            if (addContact) {
                assertEquals(1, TestUtils.deleteContact(mContentResolver, contactUri));
            }
        }
    }

    private Uri addIncoming(boolean disconnectImmediately, boolean addContact) throws Exception {
        // Add call through TelecomManager; we can't use the test methods since they assume a call
        // makes it through to the InCallService; this is blocked so it shouldn't.
        Uri testNumber = createRandomTestNumber();
        if (addContact) {
            mContactUri = TestUtils.insertContact(mContentResolver,
                    testNumber.getSchemeSpecificPart());
        }

        // Setup content observer to notify us when we call log entry is added.
        CountDownLatch callLogEntryLatch = getCallLogEntryLatch();

        Bundle extras = new Bundle();
        extras.putParcelable(TelecomManager.EXTRA_INCOMING_CALL_ADDRESS, testNumber);
        mTelecomManager.addNewIncomingCall(TestUtils.TEST_PHONE_ACCOUNT_HANDLE, extras);

        // Wait until the new incoming call is processed.
        waitOnAllHandlers(getInstrumentation());

        if (disconnectImmediately) {
            // Disconnect the call
            mInCallCallbacks.getService().disconnectAllCalls();
            assertNumCalls(mInCallCallbacks.getService(), 0);
        }

        // Wait for the content observer to report that we have gotten a new call log entry.
        callLogEntryLatch.await(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS);
        return testNumber;
    }

    private void addIncomingAndVerifyAllowed(boolean addContact) throws Exception {
        Uri testNumber = addIncoming(true, addContact);

        // Query the latest entry into the call log.
        Cursor callsCursor = mContentResolver.query(CallLog.Calls.CONTENT_URI, null,
                null, null, CallLog.Calls._ID + " DESC limit 1;");
        int numberIndex = callsCursor.getColumnIndex(CallLog.Calls.NUMBER);
        int callTypeIndex = callsCursor.getColumnIndex(CallLog.Calls.TYPE);
        int blockReasonIndex = callsCursor.getColumnIndex(CallLog.Calls.BLOCK_REASON);
        if (callsCursor.moveToNext()) {
            String number = callsCursor.getString(numberIndex);
            int callType = callsCursor.getInt(callTypeIndex);
            int blockReason = callsCursor.getInt(blockReasonIndex);
            assertEquals(testNumber.getSchemeSpecificPart(), number);
            assertEquals(CallLog.Calls.INCOMING_TYPE, callType);
            assertEquals(CallLog.Calls.BLOCK_REASON_NOT_BLOCKED, blockReason);
        } else {
            fail("Call not logged");
        }

        if (addContact && mContactUri != null) {
            assertEquals(1, TestUtils.deleteContact(mContentResolver, mContactUri));
        }
    }

    private void addIncomingAndVerifyBlocked(boolean addContact) throws Exception {
        Uri testNumber = addIncoming(false, addContact);

        // Query the latest entry into the call log.
        Cursor callsCursor = mContentResolver.query(CallLog.Calls.CONTENT_URI, null,
                null, null, CallLog.Calls._ID + " DESC limit 1;");
        int numberIndex = callsCursor.getColumnIndex(CallLog.Calls.NUMBER);
        int callTypeIndex = callsCursor.getColumnIndex(CallLog.Calls.TYPE);
        int blockReasonIndex = callsCursor.getColumnIndex(CallLog.Calls.BLOCK_REASON);
        int callScreeningAppNameIndex = callsCursor.getColumnIndex(
                CallLog.Calls.CALL_SCREENING_APP_NAME);
        int callScreeningCmpNameIndex = callsCursor.getColumnIndex(
                CallLog.Calls.CALL_SCREENING_COMPONENT_NAME);
        if (callsCursor.moveToNext()) {
            String number = callsCursor.getString(numberIndex);
            int callType = callsCursor.getInt(callTypeIndex);
            int blockReason = callsCursor.getInt(blockReasonIndex);
            String screeningAppName = callsCursor.getString(callScreeningAppNameIndex);
            String screeningComponentName = callsCursor.getString(callScreeningCmpNameIndex);
            assertEquals(testNumber.getSchemeSpecificPart(), number);
            assertEquals(CallLog.Calls.BLOCKED_TYPE, callType);
            assertEquals(CallLog.Calls.BLOCK_REASON_CALL_SCREENING_SERVICE, blockReason);
            assertEquals(TEST_APP_NAME, screeningAppName);
            assertEquals(TEST_APP_COMPONENT, screeningComponentName);
        } else {
            fail("Blocked call was not logged.");
        }

        if (addContact && mContactUri != null) {
            assertEquals(1, TestUtils.deleteContact(mContentResolver, mContactUri));
        }
    }

    private void addIncomingAndVerifyCallExtraForSilence(boolean expectedIsSilentRingingExtraSet)
            throws Exception {
        Uri testNumber = addIncoming(false, false);

        waitUntilConditionIsTrueOrTimeout(
                new Condition() {
                    @Override
                    public Object expected() {
                        return true;
                    }

                    @Override
                    public Object actual() {
                        // Verify that the call extra matches expectation
                        Call call = mInCallCallbacks.getService().getLastCall();
                        return expectedIsSilentRingingExtraSet ==
                                call.getDetails().getExtras().getBoolean(
                                        Call.EXTRA_SILENT_RINGING_REQUESTED);
                    }
                },
                TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS,
                        "Call extra - verification failed, expected the extra " +
                        "EXTRA_SILENT_RINGING_REQUESTED to be set:" +
                        expectedIsSilentRingingExtraSet);
    }

    /**
     * Sets up a binder used to control the CallScreeningServiceCtsTestApp.
     * This app is a standalone APK so that it can reside in a package name outside of the one the
     * CTS test itself runs in (since that APK is where the CTS InCallService resides).
     * @throws InterruptedException
     */
    private void setupControlBinder() throws InterruptedException {
        Intent bindIntent = new Intent(CallScreeningServiceControl.CONTROL_INTERFACE_ACTION);
        bindIntent.setComponent(CallScreeningServiceControl.CONTROL_INTERFACE_COMPONENT);
        final CountDownLatch bindLatch = new CountDownLatch(1);

        boolean success = mContext.bindService(bindIntent, new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                mCallScreeningControl = ICallScreeningControl.Stub.asInterface(service);
                bindLatch.countDown();
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                mCallScreeningControl = null;
            }
        }, Context.BIND_AUTO_CREATE);
        if (!success) {
            fail("Failed to get control interface -- bind error");
        }
        bindLatch.await(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS);
    }

    /**
     * Use RoleManager to query the previous call screening app so we can restore it later.
     */
    private void rememberPreviousCallScreeningApp() {
        runWithShellPermissionIdentity(() -> {
            List<String> callScreeningApps = mRoleManager.getRoleHolders(ROLE_CALL_SCREENING);
            if (!callScreeningApps.isEmpty()) {
                mPreviousCallScreeningPackage = callScreeningApps.get(0);
            } else {
                mPreviousCallScreeningPackage = null;
            }
        });
    }

    private void addRoleHolder(String roleName, String packageName)
            throws Exception {
        UserHandle user = Process.myUserHandle();
        Executor executor = mContext.getMainExecutor();
        LinkedBlockingQueue<Boolean> queue = new LinkedBlockingQueue(1);

        runWithShellPermissionIdentity(() -> mRoleManager.addRoleHolderAsUser(roleName,
                packageName, RoleManager.MANAGE_HOLDERS_FLAG_DONT_KILL_APP, user, executor,
                successful -> {
                    try {
                        queue.put(successful);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }));
        boolean result = queue.poll(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS);
        assertTrue(result);
    }

    private void removeRoleHolder(String roleName, String packageName)
            throws Exception {
        UserHandle user = Process.myUserHandle();
        Executor executor = mContext.getMainExecutor();
        LinkedBlockingQueue<Boolean> queue = new LinkedBlockingQueue(1);

        runWithShellPermissionIdentity(() -> mRoleManager.removeRoleHolderAsUser(roleName,
                packageName, RoleManager.MANAGE_HOLDERS_FLAG_DONT_KILL_APP, user, executor,
                successful -> {
                    try {
                        queue.put(successful);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }));
        boolean result = queue.poll(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS);
        assertTrue(result);
    }

    private void grantReadContactPermission() {
        runWithShellPermissionIdentity(() -> {
            if (mPackageManager != null) {
                mPackageManager.grantRuntimePermission(TEST_APP_PACKAGE,
                        Manifest.permission.READ_CONTACTS, mContext.getUser());
            }});
    }

    private void revokeReadContactPermission() {
        runWithShellPermissionIdentity(() -> {
                if (mPackageManager != null) {
                    mPackageManager.revokeRuntimePermission(TEST_APP_PACKAGE,
                            Manifest.permission.READ_CONTACTS, mContext.getUser());
                }});
    }

    private void verifyPermission(boolean hasPermission) {
        assertEquals(hasPermission,
                mPackageManager.checkPermission
                        (Manifest.permission.READ_CONTACTS, TEST_APP_PACKAGE)
                        == PackageManager.PERMISSION_GRANTED);
    }
}