Merge "Update DataConfigManager with new CarrierConfigManager APIs"

import android.annotation.CallbackExecutor;

import android.annotation.NonNull;

import android.annotation.StringDef;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.res.Resources;

import android.net.LinkProperties;

import android.net.NetworkCapabilities;

        log("DataConfigManager created.");

        mCarrierConfigManager = mPhone.getContext().getSystemService(CarrierConfigManager.class);

        // Register for carrier configs update

        IntentFilter filter = new IntentFilter();

        filter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);

        mPhone.getContext().registerReceiver(new BroadcastReceiver() {

            @Override

            public void onReceive(Context context, Intent intent) {

                if (intent.getAction().equals(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)) {

                    if (mPhone.getPhoneId() == intent.getIntExtra(

                            CarrierConfigManager.EXTRA_SLOT_INDEX,

                            SubscriptionManager.INVALID_SIM_SLOT_INDEX)) {

        // Callback send msg to handler thread, so callback itself can be executed in binder thread.

        mCarrierConfigManager.registerCarrierConfigChangeListener(Runnable::run,

                (slotIndex, subId, carrierId, specificCarrierId) -> {

                    if (slotIndex == mPhone.getPhoneId()) {

                        sendEmptyMessage(EVENT_CARRIER_CONFIG_CHANGED);

                    }

                }

            }

        }, filter, null, mPhone);

                });

        // Register for device config update

        DeviceConfig.addOnPropertiesChangedListener(

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.Mockito.when;

import android.os.Looper;

import android.os.PersistableBundle;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;

@TestableLooper.RunWithLooper

public class DataConfigManagerTest extends TelephonyTest {

    private DataConfigManager mDataConfigManagerUT;

    private PersistableBundle mBundle;

    @Before

    public void setUp() throws Exception {

        logd("DataConfigManagerTest +Setup!");

        super.setUp(getClass().getSimpleName());

        mBundle = mContextFixture.getCarrierConfigBundle();

        when(mCarrierConfigManager.getConfigForSubId(anyInt(), any())).thenReturn(mBundle);

        mDataConfigManagerUT = new DataConfigManager(mPhone, Looper.myLooper());

        logd("DataConfigManagerTest -Setup!");

    }

import static org.mockito.Mockito.when;

import android.annotation.NonNull;

import android.content.Intent;

import android.net.ConnectivityManager;

import android.net.InetAddresses;

import android.net.LinkAddress;

import android.telephony.PreciseDataConnectionState;

import android.telephony.ServiceState;

import android.telephony.SubscriptionInfo;

import android.telephony.SubscriptionManager;

import android.telephony.SubscriptionPlan;

import android.telephony.TelephonyDisplayInfo;

import android.telephony.TelephonyManager;

    private final SparseArray<RegistrantList> mDataCallListChangedRegistrants = new SparseArray<>();

    private DataNetworkController mDataNetworkControllerUT;

    private PersistableBundle mCarrierConfig;

    private CarrierConfigManager.CarrierConfigChangeListener mCarrierConfigChangeListener;

    private AccessNetworksManagerCallback mAccessNetworksManagerCallback;

    private LinkBandwidthEstimatorCallback mLinkBandwidthEstimatorCallback;

    private void carrierConfigChanged() {

        // Trigger carrier config reloading

        Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);

        intent.putExtra(CarrierConfigManager.EXTRA_SLOT_INDEX, 0);

        mContext.sendBroadcast(intent);

        mCarrierConfigChangeListener.onCarrierConfigChanged(0 /* logicalSlotIndex */,

                SubscriptionManager.INVALID_SUBSCRIPTION_ID,

                TelephonyManager.UNKNOWN_CARRIER_ID, TelephonyManager.UNKNOWN_CARRIER_ID);

        processAllMessages();

    }

        doReturn(-1).when(mPhone).getSubId();

        // Capture listener to emulate the carrier config change notification used later

        ArgumentCaptor<CarrierConfigManager.CarrierConfigChangeListener> listenerArgumentCaptor =

                ArgumentCaptor.forClass(CarrierConfigManager.CarrierConfigChangeListener.class);

        // Note that creating a "real" data network controller will also result in creating

        // real DataRetryManager, DataConfigManager, etc...Normally in unit test we should isolate

        // other modules and make them mocked, but only focusing on testing the unit we would like

        // between DataNetworkController and its sub-modules, we intend to make those modules "real"

        // as well, except some modules below we replaced with mocks.

        mDataNetworkControllerUT = new DataNetworkController(mPhone, Looper.myLooper());

        verify(mCarrierConfigManager).registerCarrierConfigChangeListener(any(),

                listenerArgumentCaptor.capture());

        mCarrierConfigChangeListener = listenerArgumentCaptor.getAllValues().get(0);

        assertThat(mCarrierConfigChangeListener).isNotNull();

        doReturn(mDataNetworkControllerUT).when(mPhone).getDataNetworkController();

        doReturn(1).when(mPhone).getSubId();