Fix where post-disconnect CEP causes single party call mode to exit.
On some carriers, a conference event package will be sent just prior to
disconnecting the conference. The existing logic in ImsConference would
interpret this as no longer being a single party call and enter conference
mode again, but with no participants. As a consequence the call would not
be logged.
Test: Wrote failing unit test and fixed code to verify that the problem
is fixed.
Bug: 133323379
Change-Id: I092c0f06ce26d3bafdca2173083de2c36acdc037
diff --git a/src/com/android/services/telephony/ImsConference.java b/src/com/android/services/telephony/ImsConference.java
index 1f157e3..52a3c9e 100644
--- a/src/com/android/services/telephony/ImsConference.java
+++ b/src/com/android/services/telephony/ImsConference.java
@@ -725,12 +725,16 @@
// Determine if the conference event package represents a single party conference.
// A single party conference is one where there is no other participant other than the
// conference host and one other participant.
+ // Note: We consider 0 to still be a single party conference since some carriers will
+ // send a conference event package with JUST the host in it when the conference is
+ // disconnected. We don't want to change back to conference mode prior to disconnection
+ // or we will not log the call.
boolean isSinglePartyConference = participants.stream()
.filter(p -> {
Pair<Uri, Uri> pIdent = new Pair<>(p.getHandle(), p.getEndpoint());
return !Objects.equals(mHostParticipantIdentity, pIdent);
})
- .count() == 1;
+ .count() <= 1;
// We will only process the CEP data if:
// 1. We're not emulating a single party call.
diff --git a/tests/src/com/android/services/telephony/ImsConferenceTest.java b/tests/src/com/android/services/telephony/ImsConferenceTest.java
index 56a6240..46151be 100644
--- a/tests/src/com/android/services/telephony/ImsConferenceTest.java
+++ b/tests/src/com/android/services/telephony/ImsConferenceTest.java
@@ -16,9 +16,11 @@
package com.android.services.telephony;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.any;
@@ -30,6 +32,7 @@
import android.net.Uri;
import android.os.Looper;
+import android.telecom.Conference;
import android.telecom.ConferenceParticipant;
import android.telecom.Connection;
import android.test.suitebuilder.annotation.SmallTest;
@@ -88,16 +91,83 @@
imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
Arrays.asList(participant1, participant2));
assertEquals(2, imsConference.getNumberOfParticipants());
+ verify(mMockTelephonyConnectionServiceProxy, times(2)).addExistingConnection(
+ any(PhoneAccountHandle.class), any(Connection.class),
+ eq(imsConference));
// Because we're pretending its a single party, there should be no participants any more.
imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
Arrays.asList(participant1));
assertEquals(0, imsConference.getNumberOfParticipants());
+ verify(mMockTelephonyConnectionServiceProxy, times(2)).removeConnection(
+ any(Connection.class));
+ reset(mMockTelephonyConnectionServiceProxy);
// Back to 2!
imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
Arrays.asList(participant1, participant2));
assertEquals(2, imsConference.getNumberOfParticipants());
+ verify(mMockTelephonyConnectionServiceProxy, times(2)).addExistingConnection(
+ any(PhoneAccountHandle.class), any(Connection.class),
+ eq(imsConference));
+ }
+
+ /**
+ * We have seen a scenario on a carrier where a conference event package comes in just prior to
+ * the call disconnecting with only the conference host in it. This caused a problem because
+ * it triggered exiting single party conference mode (due to a bug) and caused the call to not
+ * be logged.
+ */
+ @Test
+ @SmallTest
+ public void testSinglePartyEmulationWithPreDisconnectParticipantUpdate() {
+ when(mMockTelecomAccountRegistry.isUsingSimCallManager(any(PhoneAccountHandle.class)))
+ .thenReturn(false);
+
+ ImsConference imsConference = new ImsConference(mMockTelecomAccountRegistry,
+ mMockTelephonyConnectionServiceProxy, mConferenceHost,
+ null /* phoneAccountHandle */, () -> true /* featureFlagProxy */);
+
+ final boolean[] isConferenceState = new boolean[1];
+ Conference.Listener conferenceListener = new Conference.Listener() {
+ @Override
+ public void onConferenceStateChanged(Conference c, boolean isConference) {
+ super.onConferenceStateChanged(c, isConference);
+ isConferenceState[0] = isConference;
+ }
+ };
+ imsConference.addListener(conferenceListener);
+
+ ConferenceParticipant participant1 = new ConferenceParticipant(
+ Uri.parse("tel:6505551212"),
+ "A",
+ Uri.parse("sip:6505551212@testims.com"),
+ Connection.STATE_ACTIVE);
+ ConferenceParticipant participant2 = new ConferenceParticipant(
+ Uri.parse("tel:6505551213"),
+ "A",
+ Uri.parse("sip:6505551213@testims.com"),
+ Connection.STATE_ACTIVE);
+ imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
+ Arrays.asList(participant1, participant2));
+ assertEquals(2, imsConference.getNumberOfParticipants());
+ verify(mMockTelephonyConnectionServiceProxy, times(2)).addExistingConnection(
+ any(PhoneAccountHandle.class), any(Connection.class),
+ eq(imsConference));
+
+ // Because we're pretending its a single party, there should be only a single participant.
+ imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
+ Arrays.asList(participant1));
+ assertEquals(0, imsConference.getNumberOfParticipants());
+ verify(mMockTelephonyConnectionServiceProxy, times(2)).removeConnection(
+ any(Connection.class));
+
+ // Emulate a pre-disconnect conference event package; there will be zero participants.
+ imsConference.handleConferenceParticipantsUpdate(mConferenceHost,
+ Arrays.asList());
+
+ // We should still not be considered a conference (hence we should be logging this call).
+ assertFalse(isConferenceState[0]);
}
@Test