Merge "[SP21.1] Address comments for API council review about aosp/1172143"...

import android.net.NetworkInfo;

import android.net.NetworkInfo;

import android.net.NetworkRequest;

import android.net.NetworkRequest;

import android.net.NetworkStats;

import android.net.NetworkStats;

import android.net.netstats.provider.AbstractNetworkStatsProvider;

import android.net.netstats.provider.NetworkStatsProvider;

import android.net.netstats.provider.NetworkStatsProviderCallback;

import android.os.AsyncResult;

import android.os.AsyncResult;

import android.os.Bundle;

import android.os.Bundle;

import android.os.Handler;

import android.os.Handler;

    }

    }

    /**

    /**

     * A class implementing {@link AbstractNetworkStatsProvider} to report VT data usage to system.

     * A class implementing {@link NetworkStatsProvider} to report VT data usage to system.

     */

     */

    // TODO: Directly reports diff in updateVtDataUsage.

    // TODO: Directly reports diff in updateVtDataUsage.

    @VisibleForTesting(visibility = PRIVATE)

    @VisibleForTesting(visibility = PRIVATE)

    public class VtDataUsageProvider extends AbstractNetworkStatsProvider {

    public class VtDataUsageProvider extends NetworkStatsProvider {

        private int mToken = 0;

        private int mToken = 0;

        private NetworkStats mIfaceSnapshot = new NetworkStats(0L, 0);

        private NetworkStats mIfaceSnapshot = new NetworkStats(0L, 0);

        private NetworkStats mUidSnapshot = new NetworkStats(0L, 0);

        private NetworkStats mUidSnapshot = new NetworkStats(0L, 0);

        @Override

        @Override

        public void requestStatsUpdate(int token) {

        public void onRequestStatsUpdate(int token) {

            // If there is an ongoing VT call, request the latest VT usage from the modem. The

            // If there is an ongoing VT call, request the latest VT usage from the modem. The

            // latest usage will return asynchronously so it won't be counted in this round, but it

            // latest usage will return asynchronously so it won't be counted in this round, but it

            // will be eventually counted when next requestStatsUpdate is called.

            // will be eventually counted when next requestStatsUpdate is called.

            final NetworkStats ifaceDiff = mVtDataUsageSnapshot.subtract(mIfaceSnapshot);

            final NetworkStats ifaceDiff = mVtDataUsageSnapshot.subtract(mIfaceSnapshot);

            final NetworkStats uidDiff = mVtDataUsageUidSnapshot.subtract(mUidSnapshot);

            final NetworkStats uidDiff = mVtDataUsageUidSnapshot.subtract(mUidSnapshot);

            mVtDataUsageProviderCb.onStatsUpdated(mToken, ifaceDiff, uidDiff);

            mVtDataUsageProvider.notifyStatsUpdated(mToken, ifaceDiff, uidDiff);

            mIfaceSnapshot = mIfaceSnapshot.add(ifaceDiff);

            mIfaceSnapshot = mIfaceSnapshot.add(ifaceDiff);

            mUidSnapshot = mUidSnapshot.add(uidDiff);

            mUidSnapshot = mUidSnapshot.add(uidDiff);

            mToken = token;

            mToken = token;

        }

        }

        @Override

        @Override

        public void setLimit(String iface, long quotaBytes) {

        public void onSetLimit(String iface, long quotaBytes) {

            // No-op

            // No-op

        }

        }

        @Override

        @Override

        public void setAlert(long quotaBytes) {

        public void onSetAlert(long quotaBytes) {

            // No-op

            // No-op

        }

        }

    }

    }

    private volatile NetworkStats mVtDataUsageSnapshot = null;

    private volatile NetworkStats mVtDataUsageSnapshot = null;

    private volatile NetworkStats mVtDataUsageUidSnapshot = null;

    private volatile NetworkStats mVtDataUsageUidSnapshot = null;

    private final NetworkStatsProviderCallback mVtDataUsageProviderCb;

    private final VtDataUsageProvider mVtDataUsageProvider = new VtDataUsageProvider();

    private final AtomicInteger mDefaultDialerUid = new AtomicInteger(NetworkStats.UID_ALL);

    private final AtomicInteger mDefaultDialerUid = new AtomicInteger(NetworkStats.UID_ALL);

        final NetworkStatsManager statsManager =

        final NetworkStatsManager statsManager =

                (NetworkStatsManager) mPhone.getContext().getSystemService(

                (NetworkStatsManager) mPhone.getContext().getSystemService(

                        Context.NETWORK_STATS_SERVICE);

                        Context.NETWORK_STATS_SERVICE);

        mVtDataUsageProviderCb = statsManager.registerNetworkStatsProvider(LOG_TAG,

        statsManager.registerNetworkStatsProvider(LOG_TAG, mVtDataUsageProvider);

                new VtDataUsageProvider());

        // Allow the executor to be specified for testing.

        // Allow the executor to be specified for testing.

        mImsManagerConnector = new FeatureConnector<>(

        mImsManagerConnector = new FeatureConnector<>(

        mPhone.getDefaultPhone().getDataEnabledSettings().unregisterForDataEnabledChanged(this);

        mPhone.getDefaultPhone().getDataEnabledSettings().unregisterForDataEnabledChanged(this);

        mImsManagerConnector.disconnect();

        mImsManagerConnector.disconnect();

        if (mVtDataUsageProviderCb != null) {

        final NetworkStatsManager statsManager =

            mVtDataUsageProviderCb.unregister();

                (NetworkStatsManager) mPhone.getContext().getSystemService(

        }

                        Context.NETWORK_STATS_SERVICE);

        statsManager.unregisterNetworkStatsProvider(mVtDataUsageProvider);

    }

    }

    @Override

    @Override

import static com.android.testutils.NetworkStatsUtilsKt.assertNetworkStatsEquals;

import static com.android.testutils.NetworkStatsUtilsKt.assertNetworkStatsEquals;

import static junit.framework.Assert.assertNotNull;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import static org.mockito.Mockito.when;

import android.annotation.Nullable;

import android.content.Context;

import android.content.Context;

import android.content.SharedPreferences;

import android.content.SharedPreferences;

import android.content.pm.PackageManager;

import android.content.pm.PackageManager;

import android.net.NetworkStats;

import android.net.NetworkStats;

import android.net.NetworkStats.Entry;

import android.net.NetworkStats.Entry;

import android.net.netstats.provider.NetworkStatsProviderCallback;

import android.net.netstats.provider.INetworkStatsProviderCallback;

import android.os.Bundle;

import android.os.Bundle;

import android.os.Message;

import android.os.Message;

import android.os.PersistableBundle;

import android.os.PersistableBundle;

import android.os.RemoteException;

import android.telecom.VideoProfile;

import android.telecom.VideoProfile;

import android.telephony.CarrierConfigManager;

import android.telephony.CarrierConfigManager;

import android.telephony.DisconnectCause;

import android.telephony.DisconnectCause;

    private ImsCall mImsCall;

    private ImsCall mImsCall;

    private ImsCall mSecondImsCall;

    private ImsCall mSecondImsCall;

    private Bundle mBundle = new Bundle();

    private Bundle mBundle = new Bundle();

    private final ArgumentCaptor<VtDataUsageProvider> mVtDataUsageProviderCaptor =

    @Nullable private VtDataUsageProvider mVtDataUsageProvider;

            ArgumentCaptor.forClass(VtDataUsageProvider.class);

    @Mock

    @Mock

    private ImsCallSession mImsCallSession;

    private ImsCallSession mImsCallSession;

    @Mock

    @Mock

    @Mock

    @Mock

    private ImsPhoneConnection mImsPhoneConnection;

    private ImsPhoneConnection mImsPhoneConnection;

    @Mock

    @Mock

    private NetworkStatsProviderCallback mVtDataUsageProviderCb;

    private INetworkStatsProviderCallback mVtDataUsageProviderCb;

    private void imsCallMocking(final ImsCall imsCall) throws Exception {

    private void imsCallMocking(final ImsCall imsCall) throws Exception {

        doNothing().when(mImsManager).addNotifyStatusChangedCallbackIfAvailable(any());

        doNothing().when(mImsManager).addNotifyStatusChangedCallbackIfAvailable(any());

        doReturn(mVtDataUsageProviderCb).when(mStatsManager).registerNetworkStatsProvider(

                anyString(), any());

        mCTUT = new ImsPhoneCallTracker(mImsPhone, Runnable::run);

        mCTUT = new ImsPhoneCallTracker(mImsPhone, Runnable::run);

        mCTUT.addReasonCodeRemapping(null, "Wifi signal lost.", ImsReasonInfo.CODE_WIFI_LOST);

        mCTUT.addReasonCodeRemapping(null, "Wifi signal lost.", ImsReasonInfo.CODE_WIFI_LOST);

        mCTUT.addReasonCodeRemapping(501, "Call answered elsewhere.",

        mCTUT.addReasonCodeRemapping(501, "Call answered elsewhere.",

                "service not allowed in this location",

                "service not allowed in this location",

                ImsReasonInfo.CODE_WFC_SERVICE_NOT_AVAILABLE_IN_THIS_LOCATION);

                ImsReasonInfo.CODE_WFC_SERVICE_NOT_AVAILABLE_IN_THIS_LOCATION);

        mCTUT.setDataEnabled(true);

        mCTUT.setDataEnabled(true);

        final ArgumentCaptor<VtDataUsageProvider> vtDataUsageProviderCaptor =

                ArgumentCaptor.forClass(VtDataUsageProvider.class);

        verify(mStatsManager).registerNetworkStatsProvider(anyString(),

        verify(mStatsManager).registerNetworkStatsProvider(anyString(),

                mVtDataUsageProviderCaptor.capture());

                vtDataUsageProviderCaptor.capture());

        mVtDataUsageProvider = vtDataUsageProviderCaptor.getValue();

        assertNotNull(mVtDataUsageProvider);

        mVtDataUsageProvider.setProviderCallbackBinder(mVtDataUsageProviderCb);

        logd("ImsPhoneCallTracker initiated");

        logd("ImsPhoneCallTracker initiated");

        processAllMessages();

        processAllMessages();

    @Test

    @Test

    @SmallTest

    @SmallTest

    public void testVtDataUsageProvider() {

    public void testVtDataUsageProvider() throws RemoteException {

        final VtDataUsageProvider provider = mVtDataUsageProviderCaptor.getValue();

        mVtDataUsageProvider.onRequestStatsUpdate(11);

        provider.requestStatsUpdate(11);

        // Verify that requestStatsUpdate triggers onStatsUpdated, where the initial token should

        // Verify that requestStatsUpdate triggers onStatsUpdated, where the initial token should

        // be reported with current stats.

        // be reported with current stats.

        // Make another request, and verify stats updated accordingly, with previously issued token.

        // Make another request, and verify stats updated accordingly, with previously issued token.

        reset(mVtDataUsageProviderCb);

        reset(mVtDataUsageProviderCb);

        provider.requestStatsUpdate(13);

        mVtDataUsageProvider.onRequestStatsUpdate(13);

        assertVtDataUsageUpdated(11, 25, 25);

        assertVtDataUsageUpdated(11, 25, 25);

        // Update accumulated data usage twice. updateVtDataUsage takes accumulated stats from

        // Update accumulated data usage twice. updateVtDataUsage takes accumulated stats from

        reset(mVtDataUsageProviderCb);

        reset(mVtDataUsageProviderCb);

        mCTUT.updateVtDataUsage(call, 70);

        mCTUT.updateVtDataUsage(call, 70);

        mCTUT.updateVtDataUsage(call, 91);

        mCTUT.updateVtDataUsage(call, 91);

        verify(mVtDataUsageProviderCb, never()).onStatsUpdated(anyInt(), any(), any());

        verify(mVtDataUsageProviderCb, never()).notifyStatsUpdated(anyInt(), any(), any());

        // Verify that diff stats from last update is reported accordingly.

        // Verify that diff stats from last update is reported accordingly.

        provider.requestStatsUpdate(13);

        mVtDataUsageProvider.onRequestStatsUpdate(13);

        // Rounding error occurs so (70-51)/2 + (91-70)/2 = 19 is expected for both direction.

        // Rounding error occurs so (70-51)/2 + (91-70)/2 = 19 is expected for both direction.

        assertVtDataUsageUpdated(13, 19, 19);

        assertVtDataUsageUpdated(13, 19, 19);

    }

    }

    private void assertVtDataUsageUpdated(int expectedToken, long rxBytes, long txBytes) {

    private void assertVtDataUsageUpdated(int expectedToken, long rxBytes, long txBytes)

            throws RemoteException {

        final ArgumentCaptor<NetworkStats> ifaceStatsCaptor = ArgumentCaptor.forClass(

        final ArgumentCaptor<NetworkStats> ifaceStatsCaptor = ArgumentCaptor.forClass(

                NetworkStats.class);

                NetworkStats.class);

        final ArgumentCaptor<NetworkStats> uidStatsCaptor = ArgumentCaptor.forClass(

        final ArgumentCaptor<NetworkStats> uidStatsCaptor = ArgumentCaptor.forClass(

                NetworkStats.class);

                NetworkStats.class);

        verify(mVtDataUsageProviderCb).onStatsUpdated(eq(expectedToken), ifaceStatsCaptor.capture(),

        verify(mVtDataUsageProviderCb).notifyStatsUpdated(eq(expectedToken),

                uidStatsCaptor.capture());

                ifaceStatsCaptor.capture(), uidStatsCaptor.capture());

        // Default dialer's package uid is not set during test, thus the uid stats looks the same

        // Default dialer's package uid is not set during test, thus the uid stats looks the same

        // as iface stats and the records are always merged into the same entry.

        // as iface stats and the records are always merged into the same entry.