Implement extra key filtering for non-system dialers. am: 3da4132c7d am: d9f8ce1bde (b9f05fda) · Commits · e / os / android_packages_services_Telecomm

src/com/android/server/telecom/Call.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -2065,7 +2065,7 @@ public class Call implements CreateConnectionResponse, EventManager.Loggable,
		* @param source The source of the extras addition.
		* @param extras The extras.
		*/
		void putExtras(int source, Bundle extras) {
		public void putExtras(int source, Bundle extras) {
		if (extras == null) {
		return;
		}

src/com/android/server/telecom/InCallController.java

+19 −13

Original line number	Diff line number	Diff line
		@@ -797,7 +797,8 @@ public class InCallController extends CallsManagerListenerBase {

		ParcelableCall parcelableCall = ParcelableCallUtils.toParcelableCall(call,
		true /* includeVideoProvider */, mCallsManager.getPhoneAccountRegistrar(),
		info.isExternalCallsSupported(), includeRttCall);
		info.isExternalCallsSupported(), includeRttCall,
		info.getType() == IN_CALL_SERVICE_TYPE_SYSTEM_UI);
		try {
		inCallService.addCall(parcelableCall);
		} catch (RemoteException ignored) {
		@@ -861,7 +862,8 @@ public class InCallController extends CallsManagerListenerBase {

		ParcelableCall parcelableCall = ParcelableCallUtils.toParcelableCall(call,
		true /* includeVideoProvider */, mCallsManager.getPhoneAccountRegistrar(),
		info.isExternalCallsSupported(), includeRttCall);
		info.isExternalCallsSupported(), includeRttCall,
		info.getType() == IN_CALL_SERVICE_TYPE_SYSTEM_UI);
		try {
		inCallService.addCall(parcelableCall);
		} catch (RemoteException ignored) {
		@@ -872,15 +874,7 @@ public class InCallController extends CallsManagerListenerBase {
		// The call was regular but it is now external. We must now remove it from any
		// InCallServices which do not support external calls.
		// Remove the call by sending a call update indicating the call was disconnected.
		ParcelableCall parcelableCall = ParcelableCallUtils.toParcelableCall(
		call,
		false /* includeVideoProvider */,
		mCallsManager.getPhoneAccountRegistrar(),
		false /* supportsExternalCalls */,
		android.telecom.Call.STATE_DISCONNECTED /* overrideState */,
		false /* includeRttCall */);

		Log.i(this, "Removing external call %s ==> %s", call, parcelableCall);
		Log.i(this, "Removing external call %", call);
		for (Map.Entry<InCallServiceInfo, IInCallService> entry : mInCallServices.entrySet()) {
		InCallServiceInfo info = entry.getKey();
		if (info.isExternalCallsSupported()) {
		@@ -892,6 +886,16 @@ public class InCallController extends CallsManagerListenerBase {
		componentsUpdated.add(info.getComponentName());
		IInCallService inCallService = entry.getValue();

		ParcelableCall parcelableCall = ParcelableCallUtils.toParcelableCall(
		call,
		false /* includeVideoProvider */,
		mCallsManager.getPhoneAccountRegistrar(),
		false /* supportsExternalCalls */,
		android.telecom.Call.STATE_DISCONNECTED /* overrideState */,
		false /* includeRttCall */,
		info.getType() == IN_CALL_SERVICE_TYPE_SYSTEM_UI
		);

		try {
		inCallService.updateCall(parcelableCall);
		} catch (RemoteException ignored) {
		@@ -1387,7 +1391,8 @@ public class InCallController extends CallsManagerListenerBase {
		true /* includeVideoProvider */,
		mCallsManager.getPhoneAccountRegistrar(),
		info.isExternalCallsSupported(),
		includeRttCall));
		includeRttCall,
		info.getType() == IN_CALL_SERVICE_TYPE_SYSTEM_UI));
		} catch (RemoteException ignored) {
		}
		}
		@@ -1449,7 +1454,8 @@ public class InCallController extends CallsManagerListenerBase {
		videoProviderChanged /* includeVideoProvider */,
		mCallsManager.getPhoneAccountRegistrar(),
		info.isExternalCallsSupported(),
		rttInfoChanged && info.equals(mInCallServiceConnection.getInfo()));
		rttInfoChanged && info.equals(mInCallServiceConnection.getInfo()),
		info.getType() == IN_CALL_SERVICE_TYPE_SYSTEM_UI);
		ComponentName componentName = info.getComponentName();
		IInCallService inCallService = entry.getValue();
		componentsUpdated.add(componentName);

src/com/android/server/telecom/ParcelableCallUtils.java

+65 −5

Original line number	Diff line number	Diff line
		@@ -21,14 +21,17 @@ import static android.telecom.Call.Details.DIRECTION_OUTGOING;
		import static android.telecom.Call.Details.DIRECTION_UNKNOWN;

		import android.net.Uri;
		import android.os.Bundle;
		import android.telecom.Connection;
		import android.telecom.DisconnectCause;
		import android.telecom.ParcelableCall;
		import android.telecom.ParcelableRttCall;
		import android.telecom.TelecomManager;
		import android.text.TextUtils;

		import java.util.ArrayList;
		import java.util.Collections;
		import java.util.Iterator;
		import java.util.List;

		/**
		@@ -37,11 +40,23 @@ import java.util.List;
		public class ParcelableCallUtils {
		private static final int CALL_STATE_OVERRIDE_NONE = -1;

		/**
		* A list of extra keys which should be removed from a {@link ParcelableCall} when it is being
		* generated for the purpose of sending to a dialer other than the system dialer.
		* By convention we only pass keys namespaced with android.*, however there are some keys which
		* should not be passed to non-system dialer apps either.
		*/
		private static List<String> EXTRA_KEYS_TO_SANITIZE;
		static {
		EXTRA_KEYS_TO_SANITIZE = new ArrayList<>();
		EXTRA_KEYS_TO_SANITIZE.add(android.telecom.Connection.EXTRA_SIP_INVITE);
		}

		public static class Converter {
		public ParcelableCall toParcelableCall(Call call, boolean includeVideoProvider,
		PhoneAccountRegistrar phoneAccountRegistrar) {
		return ParcelableCallUtils.toParcelableCall(
		call, includeVideoProvider, phoneAccountRegistrar, false, false);
		call, includeVideoProvider, phoneAccountRegistrar, false, false, false);
		}

		public ParcelableCall toParcelableCallForScreening(Call call) {
		@@ -60,16 +75,23 @@ public class ParcelableCallUtils {
		* @param phoneAccountRegistrar The {@link PhoneAccountRegistrar}.
		* @param supportsExternalCalls Indicates whether the call should be parcelled for an
		* {@link InCallService} which supports external calls or not.
		* @param includeRttCall {@code true} if the RTT call should be included, {@code false}
		* otherwise.
		* @param isForSystemDialer {@code true} if this call is being parcelled for the system dialer,
		* {@code false} otherwise. When parceling for the system dialer, the entire call extras
		* is included. When parceling for anything other than the system dialer, some extra key
		* values will be stripped for privacy sake.
		*/
		public static ParcelableCall toParcelableCall(
		Call call,
		boolean includeVideoProvider,
		PhoneAccountRegistrar phoneAccountRegistrar,
		boolean supportsExternalCalls,
		boolean includeRttCall) {
		boolean includeRttCall,
		boolean isForSystemDialer) {
		return toParcelableCall(call, includeVideoProvider, phoneAccountRegistrar,
		supportsExternalCalls, CALL_STATE_OVERRIDE_NONE /* overrideState */,
		includeRttCall);
		includeRttCall, isForSystemDialer);
		}

		/**
		@@ -85,6 +107,10 @@ public class ParcelableCallUtils {
		* {@link InCallService} which supports external calls or not.
		* @param overrideState When not {@link #CALL_STATE_OVERRIDE_NONE}, use the provided state as an
		* override to whatever is defined in the call.
		* @param isForSystemDialer {@code true} if this call is being parcelled for the system dialer,
		* {@code false} otherwise. When parceling for the system dialer, the entire call extras
		* is included. When parceling for anything other than the system dialer, some extra key
		* values will be stripped for privacy sake.
		* @return The {@link ParcelableCall} containing all call information from the {@link Call}.
		*/
		public static ParcelableCall toParcelableCall(
		@@ -93,7 +119,8 @@ public class ParcelableCallUtils {
		PhoneAccountRegistrar phoneAccountRegistrar,
		boolean supportsExternalCalls,
		int overrideState,
		boolean includeRttCall) {
		boolean includeRttCall,
		boolean isForSystemDialer) {
		int state;
		if (overrideState == CALL_STATE_OVERRIDE_NONE) {
		state = getParcelableState(call, supportsExternalCalls);
		@@ -180,6 +207,13 @@ public class ParcelableCallUtils {
		callDirection = DIRECTION_OUTGOING;
		}

		Bundle extras;
		if (isForSystemDialer) {
		extras = call.getExtras();
		} else {
		extras = sanitizeExtras(call.getExtras());
		}

		return new ParcelableCall(
		call.getId(),
		state,
		@@ -205,7 +239,7 @@ public class ParcelableCallUtils {
		call.getVideoState(),
		conferenceableCallIds,
		call.getIntentExtras(),
		call.getExtras(),
		extras,
		call.getCreationTimeMillis(),
		call.getCallIdentification(),
		callDirection);
		@@ -268,6 +302,32 @@ public class ParcelableCallUtils {
		callDirection);
		}

		/**
		* Sanitize the extras bundle passed in, removing keys which should not be sent to non-system
		* dialer apps.
		* @param extras Extras bundle to sanitize.
		* @return The sanitized extras bundle.
		*/
		private static Bundle sanitizeExtras(Bundle oldExtras) {
		if (oldExtras == null) {
		return new Bundle();
		}
		Bundle extras = new Bundle(oldExtras);
		for (String key : EXTRA_KEYS_TO_SANITIZE) {
		extras.remove(key);
		}

		// As a catch-all remove any that don't start with android namespace.
		Iterator<String> toCheck = extras.keySet().iterator();
		while (toCheck.hasNext()) {
		String extraKey = toCheck.next();
		if (TextUtils.isEmpty(extraKey) \|\| !extraKey.startsWith("android.")) {
		toCheck.remove();
		}
		}
		return extras;
		}

		private static int getParcelableState(Call call, boolean supportsExternalCalls) {
		int state = CallState.NEW;
		switch (call.getState()) {

tests/src/com/android/server/telecom/tests/ParcelableCallUtilsTest.java

0 → 100644

+122 −0

Original line number	Diff line number	Diff line
		package com.android.server.telecom.tests;

		import static com.android.server.telecom.TelecomSystem.*;

		import static junit.framework.Assert.assertFalse;
		import static junit.framework.Assert.assertTrue;

		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.ArgumentMatchers.eq;
		import static org.mockito.Mockito.doNothing;
		import static org.mockito.Mockito.when;

		import android.content.ComponentName;
		import android.content.Context;
		import android.net.Uri;
		import android.os.Bundle;
		import android.os.SystemClock;
		import android.telecom.Connection;
		import android.telecom.GatewayInfo;
		import android.telecom.ParcelableCall;
		import android.telecom.PhoneAccountHandle;
		import android.test.suitebuilder.annotation.SmallTest;

		import com.android.server.telecom.Call;
		import com.android.server.telecom.CallerInfoLookupHelper;
		import com.android.server.telecom.CallsManager;
		import com.android.server.telecom.ClockProxy;
		import com.android.server.telecom.ConnectionServiceRepository;
		import com.android.server.telecom.ParcelableCallUtils;
		import com.android.server.telecom.PhoneAccountRegistrar;
		import com.android.server.telecom.PhoneNumberUtilsAdapter;
		import com.android.server.telecom.TelecomSystem;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.junit.runners.JUnit4;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		@RunWith(JUnit4.class)
		public class ParcelableCallUtilsTest extends TelecomTestCase {

		private SyncRoot mLock = new SyncRoot() {};
		@Mock private ClockProxy mClockProxy;
		@Mock private CallsManager mCallsManager;
		@Mock private CallerInfoLookupHelper mCallerInfoLookupHelper;
		@Mock private PhoneNumberUtilsAdapter mPhoneNumberUtilsAdapter;
		@Mock private PhoneAccountRegistrar mPhoneAccountRegistrar;
		private Call mCall;

		@Override
		@Before
		public void setUp() throws Exception {
		super.setUp();
		MockitoAnnotations.initMocks(this);
		when(mClockProxy.currentTimeMillis()).thenReturn(System.currentTimeMillis());
		when(mClockProxy.elapsedRealtime()).thenReturn(SystemClock.elapsedRealtime());
		when(mCallsManager.getCallerInfoLookupHelper()).thenReturn(mCallerInfoLookupHelper);
		when(mCallsManager.getPhoneAccountRegistrar()).thenReturn(mPhoneAccountRegistrar);
		when(mPhoneAccountRegistrar.getPhoneAccountUnchecked(any())).thenReturn(null);
		when(mPhoneNumberUtilsAdapter.isLocalEmergencyNumber(any(), any())).thenReturn(false);
		mCall = new Call("1",
		null /* context */,
		mCallsManager,
		mLock,
		null /* ConnectionServiceRepository */,
		mPhoneNumberUtilsAdapter,
		Uri.fromParts("tel", "6505551212", null),
		null /* GatewayInfo */,
		null /* connectionMgr */,
		new PhoneAccountHandle(
		ComponentName.unflattenFromString("com.test/Class"), "test"),
		Call.CALL_DIRECTION_INCOMING,
		false /* shouldAttachToExistingConnection */,
		false /* isConference */,
		mClockProxy /* ClockProxy */);
		}

		@SmallTest
		@Test
		public void testParcelForNonSystemDialer() {
		mCall.putExtras(Call.SOURCE_CONNECTION_SERVICE, getSomeExtras());
		ParcelableCall call = ParcelableCallUtils.toParcelableCall(mCall,
		false /* includevideoProvider */,
		null /* phoneAccountRegistrar */,
		false /* supportsExternalCalls */,
		false /* includeRttCall */,
		false /* isForSystemDialer */);

		Bundle parceledExtras = call.getExtras();
		assertFalse(parceledExtras.containsKey(Connection.EXTRA_SIP_INVITE));
		assertFalse(parceledExtras.containsKey("SomeExtra"));
		assertTrue(parceledExtras.containsKey(Connection.EXTRA_CALL_SUBJECT));
		}

		@SmallTest
		@Test
		public void testParcelForSystemDialer() {
		mCall.putExtras(Call.SOURCE_CONNECTION_SERVICE, getSomeExtras());
		ParcelableCall call = ParcelableCallUtils.toParcelableCall(mCall,
		false /* includevideoProvider */,
		null /* phoneAccountRegistrar */,
		false /* supportsExternalCalls */,
		false /* includeRttCall */,
		true /* isForSystemDialer */);

		Bundle parceledExtras = call.getExtras();
		assertTrue(parceledExtras.containsKey(Connection.EXTRA_SIP_INVITE));
		assertTrue(parceledExtras.containsKey("SomeExtra"));
		assertTrue(parceledExtras.containsKey(Connection.EXTRA_CALL_SUBJECT));
		}

		private Bundle getSomeExtras() {
		Bundle extras = new Bundle();
		extras.putString(Connection.EXTRA_SIP_INVITE, "scary data");
		extras.putString("SomeExtra", "Extra Extra");
		extras.putString(Connection.EXTRA_CALL_SUBJECT, "Blah");
		return extras;
		}
		}