Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 60d0729a authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Fixed allocate/deallocate PDU session id" into sc-qpr1-dev am: ee7c1e53 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/opt/telephony/+/15810447

Change-Id: I6f250088e8fd5d1b1d5ed0767d2d243a35afa216
parents 272ec8ce ee7c1e53

src/java/com/android/internal/telephony/dataconnection/DataConnection.java

+13 −25
Original line number Diff line number Diff line
@@ -201,7 +201,7 @@ public class DataConnection extends StateMachine { 
    private DcTesterFailBringUpAll mDcTesterFailBringUpAll;



    // Whether or not the data connection should allocate its own pdu session id

    private final boolean mDoAllocatePduSessionId;

    private boolean mDoAllocatePduSessionId;



    private static AtomicInteger mInstanceNumber = new AtomicInteger(0);

    private AsyncChannel mAc;
@@ -467,15 +467,14 @@ public class DataConnection extends StateMachine { 
    public static DataConnection makeDataConnection(Phone phone, int id, DcTracker dct,

                                                    DataServiceManager dataServiceManager,

                                                    DcTesterFailBringUpAll failBringUpAll,

                                                    DcController dcc,

                                                    boolean doAllocatePduSessionId) {

                                                    DcController dcc) {

        String transportType = (dataServiceManager.getTransportType()

                == AccessNetworkConstants.TRANSPORT_TYPE_WWAN)

                ? "C"   // Cellular

                : "I";  // IWLAN

        DataConnection dc = new DataConnection(phone, transportType + "-"

                + mInstanceNumber.incrementAndGet(), id, dct, dataServiceManager, failBringUpAll,

                dcc, doAllocatePduSessionId);

                dcc);

        dc.start();

        if (DBG) dc.log("Made " + dc.getName());

        return dc;
@@ -760,8 +759,7 @@ public class DataConnection extends StateMachine { 
    //***** Constructor (NOTE: uses dcc.getHandler() as its Handler)

    private DataConnection(Phone phone, String tagSuffix, int id,

                           DcTracker dct, DataServiceManager dataServiceManager,

                           DcTesterFailBringUpAll failBringUpAll, DcController dcc,

                           boolean doAllocatePduSessionId) {

                           DcTesterFailBringUpAll failBringUpAll, DcController dcc) {

        super("DC-" + tagSuffix, dcc);

        mTagSuffix = tagSuffix;

        setLogRecSize(300);
@@ -780,7 +778,7 @@ public class DataConnection extends StateMachine { 
        mDataRegState = mPhone.getServiceState().getDataRegistrationState();

        mIsSuspended = false;

        mDataCallSessionStats = new DataCallSessionStats(mPhone);

        mDoAllocatePduSessionId = doAllocatePduSessionId;

        mDoAllocatePduSessionId = false;



        int networkType = getNetworkType();

        mRilRat = ServiceState.networkTypeToRilRadioTechnology(networkType);
@@ -972,6 +970,7 @@ public class DataConnection extends StateMachine { 
        }



        // setup data call for REQUEST_TYPE_NORMAL

        mDoAllocatePduSessionId = mTransportType == AccessNetworkConstants.TRANSPORT_TYPE_WLAN;

        allocatePduSessionId(psi -> {

            this.setPduSessionId(psi);

            mDataServiceManager.setupDataCall(
@@ -993,7 +992,7 @@ public class DataConnection extends StateMachine { 
    }



    private void allocatePduSessionId(Consumer<Integer> allocateCallback) {

        if (getDoAllocatePduSessionId()) {

        if (mDoAllocatePduSessionId) {

            Message msg = this.obtainMessage(EVENT_ALLOCATE_PDU_SESSION_ID);

            msg.obj = allocateCallback;

            mPhone.mCi.allocatePduSessionId(msg);
@@ -1183,8 +1182,10 @@ public class DataConnection extends StateMachine { 
    }



    private void releasePduSessionId(Runnable releaseCallback) {

        // If we are not in the middle of a handover and have a real pdu session id, then we release

        if (mHandoverState != HANDOVER_STATE_BEING_TRANSFERRED

        // If the transport is IWLAN, and there is a valid PDU session id, also the data connection

        // is not being handovered, we should release the pdu session id.

        if (mTransportType == AccessNetworkConstants.TRANSPORT_TYPE_WLAN

                && mHandoverState == HANDOVER_STATE_IDLE

                && this.getPduSessionId() != PDU_SESSION_ID_NOT_SET) {

            Message msg = this.obtainMessage(EVENT_RELEASE_PDU_SESSION_ID);

            msg.obj = releaseCallback;
@@ -1354,6 +1355,7 @@ public class DataConnection extends StateMachine { 
        mHandoverFailureMode = DataCallResponse.HANDOVER_FAILURE_MODE_UNKNOWN;

        mSliceInfo = null;

        mDefaultQos = null;

        mDoAllocatePduSessionId = false;

        mQosBearerSessions.clear();

        mTrafficDescriptors.clear();

    }
@@ -1408,17 +1410,7 @@ public class DataConnection extends StateMachine { 
        } else {

            if (DBG) log("onSetupConnectionCompleted received successful DataCallResponse");

            mCid = response.getId();



            if (response.getPduSessionId() != getPduSessionId()) {

                if (getDoAllocatePduSessionId()) {

                    loge("The pdu session id on DataCallResponse is different than the one "

                            + "allocated.  response psi=" + response.getPduSessionId()

                            + ", allocated psi=" + getPduSessionId());

                } else {

            setPduSessionId(response.getPduSessionId());

                }

            }



            updatePcscfAddr(response);

            updateResponseFields(response);

            result = updateLinkProperty(response).setupResult;
@@ -2159,10 +2151,6 @@ public class DataConnection extends StateMachine { 
        return result;

    }



    private boolean getDoAllocatePduSessionId() {

        return mDoAllocatePduSessionId;

    }



    /**

     * Initialize connection, this will fail if the

     * apnSettings are not compatible.

src/java/com/android/internal/telephony/dataconnection/DcTracker.java

+1 −3
Original line number Diff line number Diff line
@@ -3624,10 +3624,8 @@ public class DcTracker extends Handler { 
        if (DBG) log("createDataConnection E");



        int id = mUniqueIdGenerator.getAndIncrement();

        boolean doAllocatePduSessionId =

                mTransportType == AccessNetworkConstants.TRANSPORT_TYPE_WLAN;

        DataConnection dataConnection = DataConnection.makeDataConnection(mPhone, id, this,

                mDataServiceManager, mDcTesterFailBringUpAll, mDcc, doAllocatePduSessionId);

                mDataServiceManager, mDcTesterFailBringUpAll, mDcc);

        mDataConnections.put(id, dataConnection);

        if (DBG) log("createDataConnection() X id=" + id + " dc=" + dataConnection);

        return dataConnection;

tests/telephonytests/src/com/android/internal/telephony/dataconnection/DataConnectionTest.java

+81 −2
Original line number Diff line number Diff line
@@ -297,7 +297,7 @@ public class DataConnectionTest extends TelephonyTest { 
            Handler h = new Handler();

            mDcc = DcController.makeDcc(mPhone, mDcTracker, mDataServiceManager, h.getLooper(), "");

            mDc = DataConnection.makeDataConnection(mPhone, 0, mDcTracker, mDataServiceManager,

                    mDcTesterFailBringUpAll, mDcc, true);

                    mDcTesterFailBringUpAll, mDcc);

        }

    }
@@ -482,6 +482,63 @@ public class DataConnectionTest extends TelephonyTest { 
                eq(false), eq(DataService.REQUEST_REASON_NORMAL), any(),

                anyInt(), any(), tdCaptor.capture(), anyBoolean(), any(Message.class));



        verify(mSimulatedCommandsVerifier, times(0))

                .allocatePduSessionId(any());



        assertEquals("spmode.ne.jp", dpCaptor.getValue().getApn());

        if (tdCaptor.getValue() != null) {

            if (mApnContext.getApnTypeBitmask() == ApnSetting.TYPE_ENTERPRISE) {

                assertEquals(null, tdCaptor.getValue().getDataNetworkName());

                assertTrue(Arrays.equals(DataConnection.getEnterpriseOsAppId(),

                        tdCaptor.getValue().getOsAppId()));

            } else {

                assertEquals("spmode.ne.jp", tdCaptor.getValue().getDataNetworkName());

                assertEquals(null, tdCaptor.getValue().getOsAppId());

            }

        }

        assertTrue(mDc.isActive());



        assertEquals(1, mDc.getPduSessionId());

        assertEquals(3, mDc.getPcscfAddresses().length);

        assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::8"::equals));

        assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c202:1d::7"::equals));

        assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::5"::equals));

    }



    @Test

    @SmallTest

    public void testConnectOnIwlan() throws Exception {

        assertTrue(mDc.isInactive());

        Field field = DataConnection.class.getDeclaredField("mTransportType");

        field.setAccessible(true);

        field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN);

        connectEvent(true);



        verify(mCT, times(1)).registerForVoiceCallStarted(any(Handler.class),

                eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_STARTED), eq(null));

        verify(mCT, times(1)).registerForVoiceCallEnded(any(Handler.class),

                eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_ENDED), eq(null));

        verify(mSimulatedCommandsVerifier, times(0))

                .registerForNattKeepaliveStatus(any(Handler.class),

                        eq(DataConnection.EVENT_KEEPALIVE_STATUS), eq(null));

        verify(mSimulatedCommandsVerifier, times(0))

                .registerForLceInfo(any(Handler.class),

                        eq(DataConnection.EVENT_LINK_CAPACITY_CHANGED), eq(null));

        verify(mVcnManager, atLeastOnce())

                .applyVcnNetworkPolicy(

                        argThat(caps ->

                                caps.hasCapability(

                                        NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)),

                        any());



        ArgumentCaptor<DataProfile> dpCaptor = ArgumentCaptor.forClass(DataProfile.class);

        ArgumentCaptor<TrafficDescriptor> tdCaptor =

                ArgumentCaptor.forClass(TrafficDescriptor.class);

        verify(mDataServiceManager, times(1)).setupDataCall(

                eq(AccessNetworkType.UTRAN), dpCaptor.capture(), eq(false),

                eq(false), eq(DataService.REQUEST_REASON_NORMAL), any(),

                anyInt(), any(), tdCaptor.capture(), anyBoolean(), any(Message.class));



        verify(mSimulatedCommandsVerifier, times(1))

                .allocatePduSessionId(any());
@@ -498,7 +555,7 @@ public class DataConnectionTest extends TelephonyTest { 
        }

        assertTrue(mDc.isActive());



        assertEquals(mDc.getPduSessionId(), 1);

        assertEquals(1, mDc.getPduSessionId());

        assertEquals(3, mDc.getPcscfAddresses().length);

        assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::8"::equals));

        assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c202:1d::7"::equals));
@@ -575,6 +632,28 @@ public class DataConnectionTest extends TelephonyTest { 
                .unregisterForNattKeepaliveStatus(any(Handler.class));

        verify(mDataServiceManager, times(1)).deactivateDataCall(eq(DEFAULT_DC_CID),

                eq(DataService.REQUEST_REASON_NORMAL), any(Message.class));

        verify(mSimulatedCommandsVerifier, times(0))

                .releasePduSessionId(any(), eq(5));



        assertTrue(mDc.isInactive());

    }



    @Test

    @SmallTest

    public void testDisconnectOnIwlan() throws Exception {

        testConnectEvent();



        Field field = DataConnection.class.getDeclaredField("mTransportType");

        field.setAccessible(true);

        field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN);

        mDc.setPduSessionId(5);

        disconnectEvent();



        verify(mSimulatedCommandsVerifier, times(0)).unregisterForLceInfo(any(Handler.class));

        verify(mSimulatedCommandsVerifier, times(0))

                .unregisterForNattKeepaliveStatus(any(Handler.class));

        verify(mDataServiceManager, times(1)).deactivateDataCall(eq(DEFAULT_DC_CID),

                eq(DataService.REQUEST_REASON_NORMAL), any(Message.class));

        verify(mSimulatedCommandsVerifier, times(1))

                .releasePduSessionId(any(), eq(5));