| /* |
| * Copyright (C) 2015 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.Connection.PROPERTY_HIGH_DEF_AUDIO; |
| import static android.telecom.Connection.PROPERTY_WIFI; |
| import static android.telecom.cts.TestUtils.*; |
| |
| import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity; |
| |
| import static org.hamcrest.CoreMatchers.instanceOf; |
| import static org.junit.Assert.assertNotEquals; |
| import static org.junit.Assert.assertThat; |
| |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.graphics.drawable.Icon; |
| import android.location.Location; |
| import android.media.AudioManager; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.ParcelUuid; |
| import android.provider.CallLog; |
| import android.telecom.Call; |
| import android.telecom.Connection; |
| import android.telecom.ConnectionRequest; |
| import android.telecom.DisconnectCause; |
| import android.telecom.GatewayInfo; |
| import android.telecom.PhoneAccount; |
| import android.telecom.PhoneAccountHandle; |
| import android.telecom.StatusHints; |
| import android.telecom.TelecomManager; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Suites of tests that verifies the various Call details. |
| */ |
| public class CallDetailsTest extends BaseTelecomTestWithMockServices { |
| |
| public static final int CONNECTION_PROPERTIES = PROPERTY_HIGH_DEF_AUDIO | PROPERTY_WIFI; |
| public static final int CONNECTION_CAPABILITIES = |
| Connection.CAPABILITY_HOLD | Connection.CAPABILITY_MUTE; |
| public static final int CALL_CAPABILITIES = |
| Call.Details.CAPABILITY_HOLD | Call.Details.CAPABILITY_MUTE; |
| public static final int CALL_PROPERTIES = |
| Call.Details.PROPERTY_HIGH_DEF_AUDIO | Call.Details.PROPERTY_WIFI; |
| public static final String CALLER_DISPLAY_NAME = "CTS test"; |
| public static final int CALLER_DISPLAY_NAME_PRESENTATION = TelecomManager.PRESENTATION_ALLOWED; |
| public static final String TEST_SUBJECT = "test"; |
| public static final String TEST_CHILD_NUMBER = "650-555-1212"; |
| public static final String TEST_FORWARDED_NUMBER = "650-555-1212"; |
| public static final String TEST_EXTRA_KEY = "android.test.extra.TEST"; |
| public static final String TEST_EXTRA_KEY2 = "android.test.extra.TEST2"; |
| public static final String TEST_EXTRA_KEY3 = "android.test.extra.TEST3"; |
| public static final float TEST_EXTRA_BITRATE = 23.85f ; |
| public static final float TEST_EXTRA_BANDWIDTH = 7.0f ; |
| public static final String TEST_INVALID_EXTRA_KEY = "blah"; |
| public static final int TEST_EXTRA_VALUE = 10; |
| public static final String TEST_EVENT = "com.test.event.TEST"; |
| public static final Uri TEST_DEFLECT_URI = Uri.fromParts("tel", "+16505551212", null); |
| private static final int ASYNC_TIMEOUT = 10000; |
| private StatusHints mStatusHints; |
| private Bundle mExtras = new Bundle(); |
| |
| private MockInCallService mInCallService; |
| private Call mCall; |
| private MockConnection mConnection; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| if (mShouldTestTelecom) { |
| PhoneAccount account = setupConnectionService( |
| new MockConnectionService() { |
| @Override |
| public Connection onCreateOutgoingConnection( |
| PhoneAccountHandle connectionManagerPhoneAccount, |
| ConnectionRequest request) { |
| Connection connection = super.onCreateOutgoingConnection( |
| connectionManagerPhoneAccount, |
| request); |
| mConnection = (MockConnection) connection; |
| // Modify the connection object created with local values. |
| connection.setConnectionCapabilities(CONNECTION_CAPABILITIES); |
| connection.setConnectionProperties(CONNECTION_PROPERTIES); |
| connection.setCallerDisplayName( |
| CALLER_DISPLAY_NAME, |
| CALLER_DISPLAY_NAME_PRESENTATION); |
| connection.setExtras(mExtras); |
| mStatusHints = new StatusHints( |
| "CTS test", |
| Icon.createWithResource( |
| getInstrumentation().getContext(), |
| R.drawable.ic_phone_24dp), |
| null); |
| connection.setStatusHints(mStatusHints); |
| lock.release(); |
| return connection; |
| } |
| }, FLAG_REGISTER | FLAG_ENABLE); |
| |
| // Make sure there is another phone account. |
| mTelecomManager.registerPhoneAccount(TestUtils.TEST_PHONE_ACCOUNT_2); |
| TestUtils.enablePhoneAccount( |
| getInstrumentation(), TestUtils.TEST_PHONE_ACCOUNT_HANDLE_2); |
| |
| /** Place a call as a part of the setup before we test the various |
| * Call details. |
| */ |
| placeAndVerifyCall(); |
| verifyConnectionForOutgoingCall(); |
| |
| mInCallService = mInCallCallbacks.getService(); |
| mCall = mInCallService.getLastCall(); |
| |
| assertCallState(mCall, Call.STATE_DIALING); |
| } |
| } |
| |
| /** |
| * Tests whether the getAccountHandle() getter returns the correct object. |
| */ |
| public void testAccountHandle() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getAccountHandle(), instanceOf(PhoneAccountHandle.class)); |
| assertEquals(TEST_PHONE_ACCOUNT_HANDLE, mCall.getDetails().getAccountHandle()); |
| } |
| |
| /** |
| * Tests whether the getCallCapabilities() getter returns the correct object. |
| */ |
| public void testCallCapabilities() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getCallCapabilities(), instanceOf(Integer.class)); |
| assertEquals(CALL_CAPABILITIES, mCall.getDetails().getCallCapabilities()); |
| assertTrue(mCall.getDetails().can(Call.Details.CAPABILITY_HOLD)); |
| assertTrue(mCall.getDetails().can(Call.Details.CAPABILITY_MUTE)); |
| assertFalse(mCall.getDetails().can(Call.Details.CAPABILITY_MANAGE_CONFERENCE)); |
| assertFalse(mCall.getDetails().can(Call.Details.CAPABILITY_RESPOND_VIA_TEXT)); |
| } |
| |
| /** |
| * Tests propagation of the local video capabilities from telephony through to in-call. |
| */ |
| public void testCallLocalVideoCapability() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| // Note: Local support for video is disabled when a call is in dialing state. |
| mConnection.setConnectionCapabilities( |
| Connection.CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL); |
| assertCallCapabilities(mCall, 0); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_LOCAL_RX); |
| assertCallCapabilities(mCall, 0); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_LOCAL_TX); |
| assertCallCapabilities(mCall, 0); |
| |
| mConnection.setConnectionCapabilities( |
| Connection.CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL); |
| assertCallCapabilities(mCall, 0); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_REMOTE_RX); |
| assertCallCapabilities(mCall, 0); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_REMOTE_TX); |
| assertCallCapabilities(mCall, 0); |
| |
| // Set call active; we expect the capabilities to make it through now. |
| mConnection.setActive(); |
| |
| mConnection.setConnectionCapabilities( |
| Connection.CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_LOCAL_RX); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_RX); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_LOCAL_TX); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX); |
| |
| mConnection.setConnectionCapabilities( |
| Connection.CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_REMOTE_RX); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORTS_VT_REMOTE_TX); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_TX); |
| } |
| |
| /** |
| * Tests passing call capabilities from Connections to Calls. |
| */ |
| public void testCallCapabilityPropagation() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_CAN_PAUSE_VIDEO); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_CAN_PAUSE_VIDEO); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_HOLD); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_HOLD); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_MANAGE_CONFERENCE); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_MANAGE_CONFERENCE); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_MERGE_CONFERENCE); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_MERGE_CONFERENCE); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_MUTE); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_MUTE); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_RESPOND_VIA_TEXT); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_RESPOND_VIA_TEXT); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SEPARATE_FROM_CONFERENCE); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SUPPORT_HOLD); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SUPPORT_HOLD); |
| |
| mConnection.setConnectionCapabilities(Connection.CAPABILITY_SWAP_CONFERENCE); |
| assertCallCapabilities(mCall, Call.Details.CAPABILITY_SWAP_CONFERENCE); |
| } |
| |
| /** |
| * Tests passing call properties from Connections to Calls. |
| */ |
| public void testCallPropertyPropagation() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_EMERGENCY_CALLBACK_MODE); |
| assertCallProperties(mCall, Call.Details.PROPERTY_EMERGENCY_CALLBACK_MODE); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_GENERIC_CONFERENCE); |
| assertCallProperties(mCall, Call.Details.PROPERTY_GENERIC_CONFERENCE); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_HIGH_DEF_AUDIO); |
| assertCallProperties(mCall, Call.Details.PROPERTY_HIGH_DEF_AUDIO); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_WIFI); |
| assertCallProperties(mCall, Call.Details.PROPERTY_WIFI); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_IS_EXTERNAL_CALL); |
| assertCallProperties(mCall, Call.Details.PROPERTY_IS_EXTERNAL_CALL); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_HAS_CDMA_VOICE_PRIVACY); |
| assertCallProperties(mCall, Call.Details.PROPERTY_HAS_CDMA_VOICE_PRIVACY); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_IS_DOWNGRADED_CONFERENCE); |
| // Not propagated |
| assertCallProperties(mCall, 0); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_IS_RTT); |
| assertCallProperties(mCall, Call.Details.PROPERTY_RTT); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_ASSISTED_DIALING); |
| assertCallProperties(mCall, Call.Details.PROPERTY_ASSISTED_DIALING); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_NETWORK_IDENTIFIED_EMERGENCY_CALL); |
| assertCallProperties(mCall, Call.Details.PROPERTY_NETWORK_IDENTIFIED_EMERGENCY_CALL); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_REMOTELY_HOSTED); |
| // Not propagated |
| assertCallProperties(mCall, 0); |
| |
| mConnection.setConnectionProperties(Connection.PROPERTY_CROSS_SIM); |
| assertCallProperties(mCall, Call.Details.PROPERTY_CROSS_SIM); |
| } |
| |
| /** |
| * Tests whether the getCallerDisplayName() getter returns the correct object. |
| */ |
| public void testCallerDisplayName() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getCallerDisplayName(), instanceOf(String.class)); |
| assertEquals(CALLER_DISPLAY_NAME, mCall.getDetails().getCallerDisplayName()); |
| } |
| |
| /** |
| * Tests whether the getCallerDisplayNamePresentation() getter returns the correct object. |
| */ |
| public void testCallerDisplayNamePresentation() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getCallerDisplayNamePresentation(), instanceOf(Integer.class)); |
| assertEquals(CALLER_DISPLAY_NAME_PRESENTATION, mCall.getDetails().getCallerDisplayNamePresentation()); |
| } |
| |
| /** |
| * Test the contacts display name. We don't have anything set up in contacts, so expect it to |
| * be null |
| */ |
| public void testContactDisplayName() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertTrue(TextUtils.isEmpty(mCall.getDetails().getContactDisplayName())); |
| } |
| |
| /** |
| * Tests whether the getCallProperties() getter returns the correct object. |
| */ |
| public void testCallProperties() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getCallProperties(), instanceOf(Integer.class)); |
| |
| assertEquals(CALL_PROPERTIES, mCall.getDetails().getCallProperties()); |
| } |
| |
| /** |
| * Tests whether the getConnectTimeMillis() getter returns the correct object. |
| */ |
| public void testConnectTimeMillis() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getConnectTimeMillis(), instanceOf(Long.class)); |
| } |
| |
| /** |
| * Tests whether the getCreationTimeMillis() getter returns the correct object. |
| */ |
| public void testCreationTimeMillis() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getCreationTimeMillis(), instanceOf(Long.class)); |
| } |
| |
| /** |
| * Tests whether the getDisconnectCause() getter returns the correct object. |
| */ |
| public void testDisconnectCause() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getDisconnectCause(), instanceOf(DisconnectCause.class)); |
| } |
| |
| /** |
| * Tests whether the getExtras() getter returns the correct object. |
| */ |
| public void testExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| if (mCall.getDetails().getExtras() != null) { |
| assertThat(mCall.getDetails().getExtras(), instanceOf(Bundle.class)); |
| } |
| } |
| |
| /** |
| * Tests whether the getIntentExtras() getter returns the correct object. |
| */ |
| public void testIntentExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getIntentExtras(), instanceOf(Bundle.class)); |
| } |
| |
| /** |
| * Tests whether the getGatewayInfo() getter returns the correct object. |
| */ |
| public void testGatewayInfo() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| if (mCall.getDetails().getGatewayInfo() != null) { |
| assertThat(mCall.getDetails().getGatewayInfo(), instanceOf(GatewayInfo.class)); |
| } |
| } |
| |
| /** |
| * Tests whether the getHandle() getter returns the correct object. |
| */ |
| public void testHandle() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getHandle(), instanceOf(Uri.class)); |
| assertEquals(getTestNumber(), mCall.getDetails().getHandle()); |
| } |
| |
| /** |
| * Tests whether the getHandlePresentation() getter returns the correct object. |
| */ |
| public void testHandlePresentation() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getHandlePresentation(), instanceOf(Integer.class)); |
| assertEquals(MockConnectionService.CONNECTION_PRESENTATION, mCall.getDetails().getHandlePresentation()); |
| } |
| |
| /** |
| * Tests whether the getStatusHints() getter returns the correct object. |
| */ |
| public void testStatusHints() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getStatusHints(), instanceOf(StatusHints.class)); |
| assertEquals(mStatusHints.getLabel(), mCall.getDetails().getStatusHints().getLabel()); |
| assertEquals( |
| mStatusHints.getIcon().toString(), |
| mCall.getDetails().getStatusHints().getIcon().toString()); |
| assertEquals(mStatusHints.getExtras(), mCall.getDetails().getStatusHints().getExtras()); |
| } |
| |
| /** |
| * Tests whether the getVideoState() getter returns the correct object. |
| */ |
| public void testVideoState() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertThat(mCall.getDetails().getVideoState(), instanceOf(Integer.class)); |
| } |
| |
| /** |
| * Tests communication of {@link Connection#setExtras(Bundle)} through to |
| * {@link Call.Details#getExtras()}. |
| */ |
| public void testExtrasPropagation() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle exampleExtras = new Bundle(); |
| exampleExtras.putString(Connection.EXTRA_CALL_SUBJECT, TEST_SUBJECT); |
| |
| // EXTRA_PRIORITY |
| exampleExtras.putInt(TelecomManager.EXTRA_PRIORITY, TelecomManager.PRIORITY_URGENT); |
| |
| // EXTRA_CALL_LOCATION |
| Location testLocation = new Location("CallDetailsTest"); |
| double latitude = 123; |
| double longitude = 456; |
| testLocation.setLatitude(latitude); |
| testLocation.setLongitude(longitude); |
| exampleExtras.putParcelable(TelecomManager.EXTRA_LOCATION, testLocation); |
| |
| // EXTRA_HAS_PICTURE |
| exampleExtras.putBoolean(TelecomManager.EXTRA_HAS_PICTURE, true); |
| |
| // EXTRA_INCOMING_PICTURE |
| Uri testIncomingPictureUrl = Uri.parse("content://carrier.xyz/picture1"); |
| exampleExtras.putParcelable(TelecomManager.EXTRA_PICTURE_URI, testIncomingPictureUrl); |
| |
| // EXTRA_OUTGOING_PICTURE |
| ParcelUuid testOutgoingPicture = ParcelUuid.fromString("11111111-2222-3333-4444-55555555"); |
| exampleExtras.putParcelable(TelecomManager.EXTRA_OUTGOING_PICTURE, testOutgoingPicture); |
| |
| exampleExtras.putString(Connection.EXTRA_CHILD_ADDRESS, TEST_CHILD_NUMBER); |
| exampleExtras.putString(Connection.EXTRA_LAST_FORWARDED_NUMBER, TEST_FORWARDED_NUMBER); |
| exampleExtras.putInt(TEST_EXTRA_KEY, TEST_EXTRA_VALUE); |
| exampleExtras.putInt(Connection.EXTRA_AUDIO_CODEC, Connection.AUDIO_CODEC_AMR); |
| exampleExtras.putFloat(Connection.EXTRA_AUDIO_CODEC_BITRATE_KBPS, TEST_EXTRA_BITRATE); |
| exampleExtras.putFloat(Connection.EXTRA_AUDIO_CODEC_BANDWIDTH_KHZ, TEST_EXTRA_BANDWIDTH); |
| mConnection.setExtras(exampleExtras); |
| |
| // Make sure we got back a bundle with the call subject key set. |
| assertCallExtras(mCall, Connection.EXTRA_CALL_SUBJECT); |
| |
| Bundle callExtras = mCall.getDetails().getExtras(); |
| assertEquals(TEST_SUBJECT, callExtras.getString(Connection.EXTRA_CALL_SUBJECT)); |
| assertEquals(TEST_CHILD_NUMBER, callExtras.getString(Connection.EXTRA_CHILD_ADDRESS)); |
| assertEquals(TEST_FORWARDED_NUMBER, |
| callExtras.getString(Connection.EXTRA_LAST_FORWARDED_NUMBER)); |
| assertEquals(TEST_EXTRA_VALUE, callExtras.getInt(TEST_EXTRA_KEY)); |
| assertEquals(Connection.AUDIO_CODEC_AMR, |
| callExtras.getInt(Connection.EXTRA_AUDIO_CODEC)); |
| assertEquals(TEST_EXTRA_BITRATE, |
| callExtras.getFloat(Connection.EXTRA_AUDIO_CODEC_BITRATE_KBPS), 0.01); |
| assertEquals(TEST_EXTRA_BANDWIDTH, |
| callExtras.getFloat(Connection.EXTRA_AUDIO_CODEC_BANDWIDTH_KHZ), 0.01); |
| |
| assertEquals(TelecomManager.PRIORITY_URGENT, exampleExtras.getInt( |
| TelecomManager.EXTRA_PRIORITY)); |
| Location testGetLocation = exampleExtras.getParcelable(TelecomManager.EXTRA_LOCATION); |
| assertEquals(latitude, testGetLocation.getLatitude(), 0); |
| assertEquals(longitude, testGetLocation.getLongitude(), 0); |
| assertEquals(true, exampleExtras.getBoolean(TelecomManager.EXTRA_HAS_PICTURE)); |
| assertEquals(testIncomingPictureUrl, |
| exampleExtras.getParcelable(TelecomManager.EXTRA_PICTURE_URI)); |
| assertEquals(testOutgoingPicture, |
| exampleExtras.getParcelable(TelecomManager.EXTRA_OUTGOING_PICTURE)); |
| } |
| |
| /** |
| * Tests that extra keys outside of the standard android.* namespace are not sent to a third |
| * party InCallService (the CTS test InCallService is technically not the OEM stock dialer). |
| */ |
| public void testExtrasBlocking() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle exampleExtras = new Bundle(); |
| exampleExtras.putString(Connection.EXTRA_CALL_SUBJECT, TEST_SUBJECT); |
| exampleExtras.putString(TEST_INVALID_EXTRA_KEY, "Secrets!"); |
| exampleExtras.putString(Connection.EXTRA_SIP_INVITE, "Sip headers!!"); |
| // Some ImsCallProfile system API extra keys we don't want to exposure to non-system |
| // dialer apps; its a bit of an implementation detail but good to verify that these are |
| // never exposed unintentionally. |
| exampleExtras.putString("oi", "5551212"); |
| exampleExtras.putString("cna", "Joe"); |
| exampleExtras.putInt("oir", TelecomManager.PRESENTATION_ALLOWED); |
| exampleExtras.putInt("cnap", TelecomManager.PRESENTATION_ALLOWED); |
| |
| mConnection.setExtras(exampleExtras); |
| |
| // Make sure we got back a bundle with the call subject key set. |
| assertCallExtras(mCall, Connection.EXTRA_CALL_SUBJECT); |
| |
| Bundle callExtras = mCall.getDetails().getExtras(); |
| assertEquals(TEST_SUBJECT, callExtras.getString(Connection.EXTRA_CALL_SUBJECT)); |
| assertFalse(callExtras.containsKey(TEST_INVALID_EXTRA_KEY)); |
| assertFalse(callExtras.containsKey(Connection.EXTRA_SIP_INVITE)); |
| // Some ImsCallProfile extra keys that should not be exposed to non-system dialers. |
| assertFalse(callExtras.containsKey("oi")); |
| assertFalse(callExtras.containsKey("cna")); |
| assertFalse(callExtras.containsKey("oir")); |
| assertFalse(callExtras.containsKey("cnap")); |
| } |
| |
| /** |
| * Tests that {@link Connection} extras changes made via {@link Connection#putExtras(Bundle)} |
| * are propagated to the {@link Call} via |
| * {@link android.telecom.Call.Callback#onDetailsChanged(Call, Call.Details)}. |
| */ |
| public void testConnectionPutExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle testBundle = new Bundle(); |
| testBundle.putString(TEST_EXTRA_KEY, TEST_SUBJECT); |
| testBundle.putInt(TEST_EXTRA_KEY2, TEST_EXTRA_VALUE); |
| testBundle.putBoolean(Connection.EXTRA_DISABLE_ADD_CALL, true); |
| mConnection.putExtras(testBundle); |
| // Wait for the 3rd invocation; setExtras is called in the setup method. |
| mOnExtrasChangedCounter.waitForCount(3, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| |
| Bundle extras = mCall.getDetails().getExtras(); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertEquals(TEST_EXTRA_VALUE, extras.getInt(TEST_EXTRA_KEY2)); |
| assertTrue(extras.getBoolean(Connection.EXTRA_DISABLE_ADD_CALL)); |
| } |
| |
| public void testConnectionHoldTone() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| // These tests are admittedly lame; the events are absorbed in telecom and start a tone and |
| // stop it. There is no other signal that the tone is starting/stopping otherwise. |
| mConnection.sendConnectionEvent(Connection.EVENT_ON_HOLD_TONE_START, null); |
| mConnection.sendConnectionEvent(Connection.EVENT_ON_HOLD_TONE_END, null); |
| } |
| |
| /** |
| * Tests that {@link Connection} extras changes made via {@link Connection#removeExtras(List)} |
| * are propagated to the {@link Call} via |
| * {@link android.telecom.Call.Callback#onDetailsChanged(Call, Call.Details)}. |
| */ |
| public void testConnectionRemoveExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| testConnectionPutExtras(); |
| |
| mConnection.removeExtras(Arrays.asList(TEST_EXTRA_KEY)); |
| verifyRemoveConnectionExtras(); |
| } |
| |
| /** |
| * Tests that {@link Connection} extras changes made via {@link Connection#removeExtras(List)} |
| * are propagated to the {@link Call} via |
| * {@link android.telecom.Call.Callback#onDetailsChanged(Call, Call.Details)}. |
| */ |
| public void testConnectionRemoveExtras2() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| testConnectionPutExtras(); |
| |
| mConnection.removeExtras(TEST_EXTRA_KEY); |
| // testConnectionPutExtra will have waited for the 3rd invocation, so wait for the 4th here. |
| verifyRemoveConnectionExtras(); |
| } |
| |
| private void verifyRemoveConnectionExtras() { |
| // testConnectionPutExtra will have waited for the 3rd invocation, so wait for the 4th here. |
| mOnExtrasChangedCounter.waitForCount(4, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| |
| Bundle extras = mCall.getDetails().getExtras(); |
| assertFalse(extras.containsKey(TEST_EXTRA_KEY)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertEquals(TEST_EXTRA_VALUE, extras.getInt(TEST_EXTRA_KEY2)); |
| } |
| |
| /** |
| * Tests that {@link Call} extras changes made via {@link Call#putExtras(Bundle)} are propagated |
| * to {@link Connection#onExtrasChanged(Bundle)}. |
| */ |
| public void testCallPutExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle testBundle = new Bundle(); |
| testBundle.putString(TEST_EXTRA_KEY, TEST_SUBJECT); |
| final InvokeCounter counter = mConnection.getInvokeCounter( |
| MockConnection.ON_EXTRAS_CHANGED); |
| mCall.putExtras(testBundle); |
| counter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| Bundle extras = mConnection.getExtras(); |
| |
| assertNotNull(extras); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY)); |
| } |
| |
| /** |
| * Tests that {@link Call} extra operations using {@link Call#removeExtras(List)} are propagated |
| * to the {@link Connection} via {@link Connection#onExtrasChanged(Bundle)}. |
| * |
| * This test specifically tests addition and removal of extras values. |
| */ |
| public void testCallRemoveExtras() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| final InvokeCounter counter = setupCallExtras(); |
| Bundle extras; |
| |
| mCall.removeExtras(Arrays.asList(TEST_EXTRA_KEY)); |
| counter.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| extras = mConnection.getExtras(); |
| assertNotNull(extras); |
| assertFalse(extras.containsKey(TEST_EXTRA_KEY)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertEquals(TEST_EXTRA_VALUE, extras.getInt(TEST_EXTRA_KEY2)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY3)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY3)); |
| |
| mCall.removeExtras(Arrays.asList(TEST_EXTRA_KEY2, TEST_EXTRA_KEY3)); |
| counter.waitForCount(3, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| extras = mConnection.getExtras(); |
| assertFalse(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertFalse(extras.containsKey(TEST_EXTRA_KEY3)); |
| } |
| |
| /** |
| * Tests that {@link Call} extra operations using {@link Call#removeExtras(String[])} are |
| * propagated to the {@link Connection} via {@link Connection#onExtrasChanged(Bundle)}. |
| * |
| * This test specifically tests addition and removal of extras values. |
| */ |
| public void testCallRemoveExtras2() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| final InvokeCounter counter = setupCallExtras(); |
| Bundle extras; |
| |
| mCall.removeExtras(TEST_EXTRA_KEY); |
| counter.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| extras = mConnection.getExtras(); |
| assertNotNull(extras); |
| assertFalse(extras.containsKey(TEST_EXTRA_KEY)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertEquals(TEST_EXTRA_VALUE, extras.getInt(TEST_EXTRA_KEY2)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY3)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY3)); |
| } |
| |
| private InvokeCounter setupCallExtras() { |
| Bundle testBundle = new Bundle(); |
| testBundle.putString(TEST_EXTRA_KEY, TEST_SUBJECT); |
| testBundle.putInt(TEST_EXTRA_KEY2, TEST_EXTRA_VALUE); |
| testBundle.putString(TEST_EXTRA_KEY3, TEST_SUBJECT); |
| final InvokeCounter counter = mConnection.getInvokeCounter( |
| MockConnection.ON_EXTRAS_CHANGED); |
| mCall.putExtras(testBundle); |
| counter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| Bundle extras = mConnection.getExtras(); |
| |
| assertNotNull(extras); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY2)); |
| assertEquals(TEST_EXTRA_VALUE, extras.getInt(TEST_EXTRA_KEY2)); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY3)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY3)); |
| return counter; |
| } |
| |
| /** |
| * Tests that {@link Connection} events are propagated from |
| * {@link Connection#sendConnectionEvent(String, Bundle)} to |
| * {@link android.telecom.Call.Callback#onConnectionEvent(Call, String, Bundle)}. |
| */ |
| public void testConnectionEvent() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle testBundle = new Bundle(); |
| testBundle.putString(TEST_EXTRA_KEY, TEST_SUBJECT); |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_CALL_PULL_FAILED, testBundle); |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| String event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| Bundle extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| |
| assertEquals(Connection.EVENT_CALL_PULL_FAILED, event); |
| assertNotNull(extras); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY)); |
| mOnConnectionEventCounter.reset(); |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_CALL_HOLD_FAILED, null); |
| // Don't expect this to make it through; used internally in Telecom. |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_MERGE_START, null); |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| assertEquals(Connection.EVENT_MERGE_START, event); |
| assertNull(extras); |
| mOnConnectionEventCounter.reset(); |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_MERGE_COMPLETE, null); |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| assertEquals(Connection.EVENT_MERGE_COMPLETE, event); |
| assertNull(extras); |
| mOnConnectionEventCounter.reset(); |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_CALL_REMOTELY_HELD, null); |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| assertEquals(Connection.EVENT_CALL_REMOTELY_HELD, event); |
| assertNull(extras); |
| mOnConnectionEventCounter.reset(); |
| |
| mConnection.sendConnectionEvent(Connection.EVENT_CALL_REMOTELY_UNHELD, null); |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| assertEquals(Connection.EVENT_CALL_REMOTELY_UNHELD, event); |
| assertNull(extras); |
| mOnConnectionEventCounter.reset(); |
| } |
| |
| /** |
| * Verifies that a request to deflect a ringing {@link Call} is relayed to a {@link Connection}. |
| */ |
| public void testDeflect() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| // Only ringing calls support deflection |
| mConnection.setRinging(); |
| assertCallState(mCall, Call.STATE_RINGING); |
| |
| final InvokeCounter counter = mConnection.getInvokeCounter(MockConnection.ON_DEFLECT); |
| mCall.deflect(TEST_DEFLECT_URI); |
| counter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| Uri address = (Uri) (counter.getArgs(0)[0]); |
| |
| assertEquals(TEST_DEFLECT_URI, address); |
| } |
| |
| /** |
| * Tests that {@link Call} events are propagated from {@link Call#sendCallEvent(String, Bundle)} |
| * to {@link Connection#onCallEvent(String, Bundle)}. |
| */ |
| public void testCallEvent() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| Bundle testBundle = new Bundle(); |
| testBundle.putString(TEST_EXTRA_KEY, TEST_SUBJECT); |
| final InvokeCounter counter = mConnection.getInvokeCounter(MockConnection.ON_CALL_EVENT); |
| mCall.sendCallEvent(TEST_EVENT, testBundle); |
| counter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| |
| String event = (String) (counter.getArgs(0)[0]); |
| Bundle extras = (Bundle) (counter.getArgs(0)[1]); |
| |
| assertEquals(TEST_EVENT, event); |
| assertNotNull(extras); |
| assertTrue(extras.containsKey(TEST_EXTRA_KEY)); |
| assertEquals(TEST_SUBJECT, extras.getString(TEST_EXTRA_KEY)); |
| } |
| |
| /** |
| * Verifies that the AudioManager audio mode changes as expected based on whether a connection |
| * is using voip audio mode or not. |
| */ |
| public void testSetVoipAudioMode() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| mConnection.setAudioModeIsVoip(true); |
| assertCallProperties(mCall, Call.Details.PROPERTY_VOIP_AUDIO_MODE); |
| AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); |
| assertAudioMode(audioManager, AudioManager.MODE_IN_COMMUNICATION); |
| |
| mConnection.setAudioModeIsVoip(false); |
| assertDoesNotHaveCallProperties(mCall, Call.Details.PROPERTY_VOIP_AUDIO_MODE); |
| assertAudioMode(audioManager, AudioManager.MODE_IN_CALL); |
| } |
| |
| /** |
| * Tests whether the getCallDirection() getter returns correct call direction. |
| */ |
| public void testGetCallDirection() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| assertEquals(Call.Details.DIRECTION_OUTGOING, mCall.getDetails().getCallDirection()); |
| assertFalse(Call.Details.DIRECTION_INCOMING == mCall.getDetails().getCallDirection()); |
| assertFalse(Call.Details.DIRECTION_UNKNOWN == mCall.getDetails().getCallDirection()); |
| } |
| |
| /** |
| * Asserts that a call's extras contain a specified key. |
| * |
| * @param call The call. |
| * @param expectedKey The expected extras key. |
| */ |
| private void assertCallExtras(final Call call, final String expectedKey) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedKey; |
| } |
| |
| @Override |
| public Object actual() { |
| return call.getDetails().getExtras().containsKey(expectedKey) ? expectedKey |
| : ""; |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Call should have extras key " + expectedKey |
| ); |
| } |
| |
| /** |
| * Tests whether the CallLogManager logs the features of a call(HD call, Wifi call, VoLTE) |
| * correctly. |
| */ |
| public void testLogFeatures() throws Exception { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| // Register content observer on call log and get latch |
| CountDownLatch callLogEntryLatch = getCallLogEntryLatch(); |
| |
| Bundle testBundle = new Bundle(); |
| testBundle.putInt(TelecomManager.EXTRA_CALL_NETWORK_TYPE, |
| TelephonyManager.NETWORK_TYPE_LTE); |
| mConnection.putExtras(testBundle); |
| // Wait for the 2nd invocation; setExtras is called in the setup method. |
| mOnExtrasChangedCounter.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| |
| Bundle extra = mCall.getDetails().getExtras(); |
| |
| mCall.disconnect(); |
| |
| // Wait on the call log latch. |
| callLogEntryLatch.await(ASYNC_TIMEOUT, TimeUnit.MILLISECONDS); |
| |
| // Verify the contents of the call log |
| Cursor callsCursor = mContext.getContentResolver().query(CallLog.Calls.CONTENT_URI, null, |
| null, null, "_id DESC"); |
| callsCursor.moveToFirst(); |
| int features = callsCursor.getInt(callsCursor.getColumnIndex("features")); |
| assertEquals(CallLog.Calls.FEATURES_HD_CALL, |
| features & CallLog.Calls.FEATURES_HD_CALL); |
| assertEquals(CallLog.Calls.FEATURES_WIFI, features & CallLog.Calls.FEATURES_WIFI); |
| assertEquals(CallLog.Calls.FEATURES_VOLTE, features & CallLog.Calls.FEATURES_VOLTE); |
| } |
| |
| /** |
| * Verifies operation of the test telecom call ID system APIs. |
| */ |
| public void testTelecomCallId() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| mConnection.setTelecomCallId("Hello"); |
| assertEquals("Hello", mConnection.getTelecomCallId()); |
| } |
| |
| /** |
| * Verifies propagation of radio tech extra. |
| */ |
| public void testSetCallRadioTech() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| Bundle radioTechExtras = new Bundle(); |
| radioTechExtras.putInt(TelecomManager.EXTRA_CALL_NETWORK_TYPE, |
| TelephonyManager.NETWORK_TYPE_LTE); |
| mConnection.putExtras(radioTechExtras); |
| |
| assertCallExtras(mCall, TelecomManager.EXTRA_CALL_NETWORK_TYPE); |
| assertEquals(TelephonyManager.NETWORK_TYPE_LTE, |
| mCall.getDetails().getExtras().getInt(TelecomManager.EXTRA_CALL_NETWORK_TYPE)); |
| } |
| |
| /** |
| * Verifies resetting the connection time. |
| */ |
| public void testResetConnectionTime() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| long currentTime = mConnection.getConnectTimeMillis(); |
| mConnection.resetConnectionTime(); |
| |
| // Make sure the connect time isn't the original value. |
| assertCallConnectTimeChanged(mCall, currentTime); |
| } |
| |
| /** |
| * Verifies {@link Connection#notifyConferenceMergeFailed()} results in the |
| * {@link Connection#EVENT_CALL_MERGE_FAILED} connection event being received by the telecom |
| * call. |
| */ |
| public void testMergeFail() { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| |
| mConnection.notifyConferenceMergeFailed(); |
| |
| mOnConnectionEventCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| String event = (String) (mOnConnectionEventCounter.getArgs(0)[1]); |
| Bundle extras = (Bundle) (mOnConnectionEventCounter.getArgs(0)[2]); |
| |
| assertEquals(Connection.EVENT_CALL_MERGE_FAILED, event); |
| assertNull(extras); |
| } |
| |
| /** |
| * Verifies {@link Connection#setPhoneAccountHandle(PhoneAccountHandle)} propagates to the |
| * dialer app. |
| */ |
| public void testChangePhoneAccount() throws Exception { |
| if (!mShouldTestTelecom) { |
| return; |
| } |
| mConnection.setActive(); |
| assertCallState(mCall, Call.STATE_ACTIVE); |
| |
| mConnection.setPhoneAccountHandle(TEST_PHONE_ACCOUNT_HANDLE_2); |
| assertEquals(TEST_PHONE_ACCOUNT_HANDLE_2, mConnection.getPhoneAccountHandle()); |
| mOnPhoneAccountChangedCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); |
| assertEquals(TEST_PHONE_ACCOUNT_HANDLE_2, mOnPhoneAccountChangedCounter.getArgs(0)[1]); |
| } |
| } |
