Merge "[Settings] MobileNetworkActivity Refactor"

src/com/android/settings/network/ActiveSubsciptionsListener.java

@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2019 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 com.android.settings.network;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.telephony.CarrierConfigManager;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
+import android.text.TextUtils;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.android.internal.telephony.TelephonyIntents;
+
+import java.util.List;
+
+/**
+ * A listener for active subscription change
+ */
+public abstract class ActiveSubsciptionsListener
+        extends SubscriptionManager.OnSubscriptionsChangedListener {
+
+    /**
+     * Constructor
+     *
+     * @param context of this listener
+     */
+    public ActiveSubsciptionsListener(Context context) {
+        mContext = context;
+
+        mSubscriptionChangeIntentFilter = new IntentFilter();
+        mSubscriptionChangeIntentFilter.addAction(
+                CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
+        mSubscriptionChangeIntentFilter.addAction(
+                TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
+
+        mSubscriptionChangeReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                if (isInitialStickyBroadcast()) {
+                    return;
+                }
+                final String action = intent.getAction();
+                if (TextUtils.isEmpty(action)) {
+                    return;
+                }
+                if (CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED.equals(action)) {
+                    final int subId = intent.getIntExtra(
+                            CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX,
+                            SubscriptionManager.INVALID_SUBSCRIPTION_ID);
+                    if (!clearCachedSubId(subId)) {
+                        return;
+                    }
+                }
+                onSubscriptionsChanged();
+            }
+        };
+    }
+
+    private Context mContext;
+
+    private boolean mIsMonitoringDataChange;
+    private boolean mIsCachedDataAvailable;
+    private SubscriptionManager mSubscriptionManager;
+
+    private IntentFilter mSubscriptionChangeIntentFilter;
+
+    @VisibleForTesting
+    BroadcastReceiver mSubscriptionChangeReceiver;
+
+    private List<SubscriptionInfo> mCachedActiveSubscriptionInfo;
+
+    /**
+     * Active subscriptions got changed
+     */
+    public abstract void onChanged();
+
+    @Override
+    public void onSubscriptionsChanged() {
+        // clear value in cache
+        clearCache();
+        listenerNotify();
+    }
+
+    /**
+     * Start listening subscriptions change
+     */
+    public void start() {
+        monitorSubscriptionsChange(true);
+    }
+
+    /**
+     * Stop listening subscriptions change
+     */
+    public void stop() {
+        monitorSubscriptionsChange(false);
+    }
+
+    /**
+     * Get SubscriptionManager
+     *
+     * @return a SubscriptionManager
+     */
+    public SubscriptionManager getSubscriptionManager() {
+        if (mSubscriptionManager == null) {
+            mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class);
+        }
+        return mSubscriptionManager;
+    }
+
+    /**
+     * Get a list of active subscription info
+     *
+     * @return A list of active subscription info
+     */
+    public List<SubscriptionInfo> getActiveSubscriptionsInfo() {
+        if (mIsCachedDataAvailable) {
+            return mCachedActiveSubscriptionInfo;
+        }
+        mIsCachedDataAvailable = true;
+        mCachedActiveSubscriptionInfo = getSubscriptionManager().getActiveSubscriptionInfoList();
+        return mCachedActiveSubscriptionInfo;
+    }
+
+    /**
+     * Get an active subscription info with given subscription ID
+     *
+     * @param subId target subscription ID
+     * @return A subscription info which is active list
+     */
+    public SubscriptionInfo getActiveSubscriptionInfo(int subId) {
+        final List<SubscriptionInfo> subInfoList = getActiveSubscriptionsInfo();
+        if (subInfoList == null) {
+            return null;
+        }
+        for (SubscriptionInfo subInfo : subInfoList) {
+            if (subInfo.getSubscriptionId() == subId) {
+                return subInfo;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Clear data cached within listener
+     */
+    public void clearCache() {
+        mIsCachedDataAvailable = false;
+        mCachedActiveSubscriptionInfo = null;
+    }
+
+    private void monitorSubscriptionsChange(boolean on) {
+        if (mIsMonitoringDataChange == on) {
+            return;
+        }
+        mIsMonitoringDataChange = on;
+        if (on) {
+            mContext.registerReceiver(mSubscriptionChangeReceiver,
+                    mSubscriptionChangeIntentFilter);
+            getSubscriptionManager().addOnSubscriptionsChangedListener(this);
+            listenerNotify();
+        } else {
+            mContext.unregisterReceiver(mSubscriptionChangeReceiver);
+            getSubscriptionManager().removeOnSubscriptionsChangedListener(this);
+            clearCache();
+        }
+    }
+
+    private void listenerNotify() {
+        if (!mIsMonitoringDataChange) {
+            return;
+        }
+        onChanged();
+    }
+
+    private boolean clearCachedSubId(int subId) {
+        if ((!mIsCachedDataAvailable) || (mCachedActiveSubscriptionInfo == null)) {
+            return false;
+        }
+        for (SubscriptionInfo subInfo : mCachedActiveSubscriptionInfo) {
+            if (subInfo.getSubscriptionId() == subId) {
+                clearCache();
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/com/android/settings/network/telephony/MobileNetworkActivity.java

@@ -17,16 +17,11 @@
 package com.android.settings.network.telephony;
 
 import android.app.ActionBar;
-import android.content.BroadcastReceiver;
-import android.content.Context;
 import android.content.Intent;
-import android.content.IntentFilter;
 import android.os.Bundle;
 import android.os.UserManager;
 import android.provider.Settings;
-import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionInfo;
-import android.telephony.SubscriptionManager;
 import android.view.Menu;
 import android.view.View;
 
@@ -36,20 +31,20 @@ import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentManager;
 import androidx.fragment.app.FragmentTransaction;
 
-import com.android.internal.telephony.TelephonyIntents;
 import com.android.internal.util.CollectionUtils;
 import com.android.settings.R;
 import com.android.settings.core.FeatureFlags;
 import com.android.settings.core.SettingsBaseActivity;
 import com.android.settings.development.featureflags.FeatureFlagPersistent;
-import com.android.settings.network.SubscriptionUtil;
+import com.android.settings.network.ActiveSubsciptionsListener;
 
 import com.google.android.material.bottomnavigation.BottomNavigationView;
 
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 
+/**
+ * Activity for displaying MobileNetworkSettings
+ */
 public class MobileNetworkActivity extends SettingsBaseActivity {
 
     private static final String TAG = "MobileNetworkActivity";
@@ -58,31 +53,21 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
     @VisibleForTesting
     static final int SUB_ID_NULL = Integer.MIN_VALUE;
 
-    @VisibleForTesting
+    private ActiveSubsciptionsListener mSubscriptionAccess;
-    SubscriptionManager mSubscriptionManager;
+    private int mCurSubscriptionId;
-    @VisibleForTesting
-    int mCurSubscriptionId;
-    @VisibleForTesting
-    List<SubscriptionInfo> mSubscriptionInfos = new ArrayList<>();
-    private PhoneChangeReceiver mPhoneChangeReceiver;
-
-    private final SubscriptionManager.OnSubscriptionsChangedListener
-            mOnSubscriptionsChangeListener
-            = new SubscriptionManager.OnSubscriptionsChangedListener() {
-        @Override
-        public void onSubscriptionsChanged() {
-            if (!Objects.equals(mSubscriptionInfos,
-                    mSubscriptionManager.getActiveSubscriptionInfoList(true))) {
-                updateSubscriptions(null);
-            }
-        }
-    };
 
     @Override
     protected void onNewIntent(Intent intent) {
         super.onNewIntent(intent);
         setIntent(intent);
-        updateSubscriptions(null);
+
+        int updateSubscriptionIndex = SUB_ID_NULL;
+        if (intent != null) {
+            updateSubscriptionIndex = intent.getIntExtra(Settings.EXTRA_SUB_ID, SUB_ID_NULL);
+        }
+
+        mCurSubscriptionId = updateSubscriptionIndex;
+        updateSubscriptions(getSubscription());
     }
 
     @Override
@@ -91,6 +76,7 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
         final UserManager userManager = this.getSystemService(UserManager.class);
         if (!userManager.isAdminUser()) {
             this.finish();
+            return;
         }
 
         if (FeatureFlagPersistent.isEnabled(this, FeatureFlags.NETWORK_INTERNET_V2)) {
@@ -99,21 +85,13 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
             setContentView(R.layout.mobile_network_settings_container);
         }
         setActionBar(findViewById(R.id.mobile_action_bar));
-        mPhoneChangeReceiver = new PhoneChangeReceiver(this, new PhoneChangeReceiver.Client() {
-            @Override
-            public void onPhoneChange() {
-                // When the radio or carrier config changes (ex: CDMA->GSM), refresh the fragment.
-                switchFragment(new MobileNetworkSettings(), mCurSubscriptionId,
-                        true /* forceUpdate */);
-            }
 
-            @Override
+        mSubscriptionAccess = new ActiveSubsciptionsListener(this) {
-            public int getSubscriptionId() {
+            public void onChanged() {
-                return mCurSubscriptionId;
+                updateSubscriptions(getSubscription());
             }
-        });
+        };
-        mSubscriptionManager = getSystemService(SubscriptionManager.class);
+
-        mSubscriptionInfos = mSubscriptionManager.getActiveSubscriptionInfoList(true);
         mCurSubscriptionId = savedInstanceState != null
                 ? savedInstanceState.getInt(Settings.EXTRA_SUB_ID, SUB_ID_NULL)
                 : SUB_ID_NULL;
@@ -123,21 +101,21 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
             actionBar.setDisplayHomeAsUpEnabled(true);
         }
 
-        updateSubscriptions(savedInstanceState);
+        final SubscriptionInfo subscription = getSubscription();
+        updateTitleAndNavigation(subscription);
     }
 
     @Override
     protected void onStart() {
         super.onStart();
-        mPhoneChangeReceiver.register();
+        mSubscriptionAccess.start();
-        mSubscriptionManager.addOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener);
+        updateSubscriptions(getSubscription());
     }
 
     @Override
     protected void onStop() {
         super.onStop();
-        mPhoneChangeReceiver.unregister();
+        mSubscriptionAccess.stop();
-        mSubscriptionManager.removeOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener);
     }
 
     @Override
@@ -151,25 +129,30 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
         outState.putInt(Settings.EXTRA_SUB_ID, mCurSubscriptionId);
     }
 
-    @VisibleForTesting
+    private void updateTitleAndNavigation(SubscriptionInfo subscription) {
-    void updateSubscriptions(Bundle savedInstanceState) {
         // Set the title to the name of the subscription. If we don't have subscription info, the
         // title will just default to the label for this activity that's already specified in
         // AndroidManifest.xml.
-        final SubscriptionInfo subscription = getSubscription();
         if (subscription != null) {
             setTitle(subscription.getDisplayName());
         }
 
-        mSubscriptionInfos = mSubscriptionManager.getActiveSubscriptionInfoList(true);
-
         if (!FeatureFlagPersistent.isEnabled(this, FeatureFlags.NETWORK_INTERNET_V2)) {
             updateBottomNavigationView();
         }
-
-        if (savedInstanceState == null) {
-            switchFragment(new MobileNetworkSettings(), getSubscriptionId());
     }
+
+    @VisibleForTesting
+    void updateSubscriptions(SubscriptionInfo subscription) {
+        if (subscription == null) {
+            return;
+        }
+        final int subscriptionIndex = subscription.getSubscriptionId();
+
+        updateTitleAndNavigation(subscription);
+        switchFragment(subscription);
+
+        mCurSubscriptionId = subscriptionIndex;
     }
 
     /**
@@ -179,125 +162,73 @@ public class MobileNetworkActivity extends SettingsBaseActivity {
      */
     @VisibleForTesting
     SubscriptionInfo getSubscription() {
-        final Intent intent = getIntent();
+        if (mCurSubscriptionId != SUB_ID_NULL) {
-        if (intent != null) {
+            final SubscriptionInfo subInfo =
-            final int subId = intent.getIntExtra(Settings.EXTRA_SUB_ID, SUB_ID_NULL);
+                    mSubscriptionAccess.getActiveSubscriptionInfo(mCurSubscriptionId);
-            if (subId != SUB_ID_NULL) {
+            if (subInfo != null) {
-                for (SubscriptionInfo subscription :
+                return subInfo;
-                        SubscriptionUtil.getAvailableSubscriptions(this)) {
-                    if (subscription.getSubscriptionId() == subId) {
-                        return subscription;
             }
         }
-            }
+        final List<SubscriptionInfo> subInfos = mSubscriptionAccess.getActiveSubscriptionsInfo();
-        }
+        if (CollectionUtils.isEmpty(subInfos)) {
-
-        if (CollectionUtils.isEmpty(mSubscriptionInfos)) {
             return null;
         }
-        return mSubscriptionInfos.get(0);
+        return subInfos.get(0);
     }
 
-    /**
+    private void updateBottomNavigationView() {
-     * Get the current subId to display.
-     */
-    @VisibleForTesting
-    int getSubscriptionId() {
-        final SubscriptionInfo subscription = getSubscription();
-        if (subscription != null) {
-            return subscription.getSubscriptionId();
-        }
-        return SubscriptionManager.INVALID_SUBSCRIPTION_ID;
-    }
-
-    @VisibleForTesting
-    void updateBottomNavigationView() {
         final BottomNavigationView navigation = findViewById(R.id.bottom_nav);
 
-        if (CollectionUtils.size(mSubscriptionInfos) <= 1) {
+        final List<SubscriptionInfo> subInfos = mSubscriptionAccess.getActiveSubscriptionsInfo();
+        if (CollectionUtils.size(subInfos) <= 1) {
             navigation.setVisibility(View.GONE);
         } else {
             final Menu menu = navigation.getMenu();
             menu.clear();
-            for (int i = 0, size = mSubscriptionInfos.size(); i < size; i++) {
+            for (int i = 0, size = subInfos.size(); i < size; i++) {
-                final SubscriptionInfo subscriptionInfo = mSubscriptionInfos.get(i);
+                final SubscriptionInfo subscriptionInfo = subInfos.get(i);
                 menu.add(0, subscriptionInfo.getSubscriptionId(), i,
                         subscriptionInfo.getDisplayName())
                         .setIcon(R.drawable.ic_settings_sim);
             }
             navigation.setOnNavigationItemSelectedListener(item -> {
-                switchFragment(new MobileNetworkSettings(), item.getItemId());
+                final int subId = item.getItemId();
+                if (!isSubscriptionChanged(subId)) {
+                    return true;
+                }
+                final SubscriptionInfo subscriptionInfo = mSubscriptionAccess
+                        .getActiveSubscriptionInfo(subId);
+                if (subscriptionInfo == null) {
+                    return true;
+                }
+                updateSubscriptions(subscriptionInfo);
                 return true;
             });
+            navigation.setVisibility(View.VISIBLE);
         }
     }
 
     @VisibleForTesting
-    void switchFragment(Fragment fragment, int subscriptionId) {
+    void switchFragment(SubscriptionInfo subInfo) {
-        switchFragment(fragment, subscriptionId, false /* forceUpdate */);
-    }
-
-    @VisibleForTesting
-    void switchFragment(Fragment fragment, int subscriptionId, boolean forceUpdate) {
-        if (mCurSubscriptionId != SUB_ID_NULL && subscriptionId == mCurSubscriptionId
-                && !forceUpdate) {
-            return;
-        }
         final FragmentManager fragmentManager = getSupportFragmentManager();
         final FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
-        final Bundle bundle = new Bundle();
-        bundle.putInt(Settings.EXTRA_SUB_ID, subscriptionId);
 
+        final int subId = subInfo.getSubscriptionId();
+        final Bundle bundle = new Bundle();
+        bundle.putInt(Settings.EXTRA_SUB_ID, subId);
+
+        final Fragment fragment = new MobileNetworkSettings();
         fragment.setArguments(bundle);
-        fragmentTransaction.replace(R.id.main_content, fragment,
+        fragmentTransaction.replace(R.id.main_content, fragment, buildFragmentTag(subId));
-                buildFragmentTag(subscriptionId));
         fragmentTransaction.commit();
-        mCurSubscriptionId = subscriptionId;
     }
 
-    private String buildFragmentTag(int subscriptionId) {
+    @VisibleForTesting
+    String buildFragmentTag(int subscriptionId) {
         return MOBILE_SETTINGS_TAG + subscriptionId;
     }
 
-    @VisibleForTesting
+    private boolean isSubscriptionChanged(int subscriptionId) {
-    static class PhoneChangeReceiver extends BroadcastReceiver {
+        return (subscriptionId == SUB_ID_NULL) || (subscriptionId != mCurSubscriptionId);
-        private Context mContext;
-        private Client mClient;
-
-        interface Client {
-            void onPhoneChange();
-            int getSubscriptionId();
-        }
-
-        public PhoneChangeReceiver(Context context, Client client) {
-            mContext = context;
-            mClient = client;
-        }
-
-        public void register() {
-            final IntentFilter intentFilter = new IntentFilter();
-            intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
-            intentFilter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
-            mContext.registerReceiver(this, intentFilter);
-        }
-
-        public void unregister() {
-            mContext.unregisterReceiver(this);
-        }
-
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            if (isInitialStickyBroadcast()) {
-                return;
-            }
-            if (intent.getAction().equals(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)) {
-                if (!intent.hasExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX) ||
-                        intent.getIntExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, -1)
-                                != mClient.getSubscriptionId()) {
-                    return;
-                }
-            }
-            mClient.onPhoneChange();
-        }
     }
 }

tests/robotests/Android.bp

@@ -31,6 +31,9 @@ android_app {
         "androidx-constraintlayout_constraintlayout-solver",
         "androidx.lifecycle_lifecycle-runtime",
         "androidx.lifecycle_lifecycle-extensions",
+        "androidx.test.core",
+        "androidx.test.runner",
+        "androidx.test.ext.junit",
         "guava",
         "jsr305",
         "settings-contextual-card-protos-lite",
@@ -61,7 +64,7 @@ android_robolectric_test {
         "SettingsLib-robo-testutils",
     ],
 
-    java_resource_dirs: ["config"],
+    java_resource_dirs: ["config", "resources"],
 
     instrumentation_for: "SettingsRoboTestStub",
 

tests/robotests/resources/META-INF/services/androidx.test.internal.platform.ThreadChecker

@@ -0,0 +1 @@
+org.robolectric.android.internal.NoOpThreadChecker

tests/robotests/resources/META-INF/services/androidx.test.internal.platform.app.ActivityInvoker

@@ -0,0 +1 @@
+org.robolectric.android.internal.LocalActivityInvoker

tests/robotests/resources/META-INF/services/androidx.test.internal.platform.content.PermissionGranter

@@ -0,0 +1 @@
+org.robolectric.android.internal.LocalPermissionGranter

tests/robotests/resources/META-INF/services/androidx.test.internal.platform.os.ControlledLooper

@@ -0,0 +1 @@
+org.robolectric.android.internal.LocalControlledLooper

tests/robotests/resources/META-INF/services/androidx.test.platform.ui.UiController

@@ -0,0 +1 @@
+org.robolectric.android.internal.LocalUiController

tests/robotests/src/com/android/settings/network/ActiveSubsciptionsListenerTest.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2019 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 com.android.settings.network;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.telephony.CarrierConfigManager;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
+
+import com.android.internal.telephony.TelephonyIntents;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+public class ActiveSubsciptionsListenerTest {
+
+    @Mock
+    private SubscriptionManager mSubscriptionManager;
+    @Mock
+    private SubscriptionInfo mSubscriptionInfo1;
+    @Mock
+    private SubscriptionInfo mSubscriptionInfo2;
+
+    private Context mContext;
+    private ActiveSubsciptionsListener mListener;
+    private List<SubscriptionInfo> mActiveSubscriptions;
+    private BroadcastReceiver mSubscriptionChangeReceiver;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager);
+        mActiveSubscriptions = new ArrayList<SubscriptionInfo>();
+    }
+
+    @Test
+    public void constructor_noListeningWasSetup() {
+        mListener = spy(new ActiveSubsciptionsListener(mContext) {
+            public void onChanged() {}
+        });
+        verify(mSubscriptionManager, never()).addOnSubscriptionsChangedListener(any());
+        verify(mContext, never()).registerReceiver(any(), any());
+        verify(mListener, never()).onChanged();
+    }
+
+    @Test
+    public void start_onChangedShouldAlwaysBeCalled() {
+        mListener = spy(new ActiveSubsciptionsListener(mContext) {
+            public void onChanged() {}
+        });
+        mSubscriptionChangeReceiver = spy(mListener.mSubscriptionChangeReceiver);
+        when(mSubscriptionChangeReceiver.isInitialStickyBroadcast()).thenReturn(false);
+
+        mActiveSubscriptions.add(mSubscriptionInfo1);
+        mActiveSubscriptions.add(mSubscriptionInfo2);
+        when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(mActiveSubscriptions);
+
+        final Intent intentSubscription =
+                new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
+        final Intent intentRadioTech =
+                new Intent(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
+
+        mSubscriptionChangeReceiver.onReceive(mContext, intentSubscription);
+        mSubscriptionChangeReceiver.onReceive(mContext, intentRadioTech);
+        verify(mListener, never()).onChanged();
+
+        mListener.start();
+
+        mSubscriptionChangeReceiver.onReceive(mContext, intentSubscription);
+        verify(mListener, atLeastOnce()).onChanged();
+
+        mSubscriptionChangeReceiver.onReceive(mContext, intentRadioTech);
+        verify(mListener, times(1)).onChanged();
+
+        mListener.stop();
+
+        mContext.sendStickyBroadcast(intentSubscription);
+        mContext.sendStickyBroadcast(intentRadioTech);
+        verify(mListener, times(1)).onChanged();
+    }
+
+    @Test
+    public void constructor_alwaysFetchAndCacheResult() {
+        mListener = spy(new ActiveSubsciptionsListener(mContext) {
+            public void onChanged() {}
+        });
+        mActiveSubscriptions.add(mSubscriptionInfo1);
+        mActiveSubscriptions.add(mSubscriptionInfo2);
+
+        List<SubscriptionInfo> subInfoList = null;
+        int numberOfAccess = 0;
+        for (int numberOfSubInfo = mActiveSubscriptions.size(); numberOfSubInfo >= 0;
+                numberOfSubInfo--) {
+            if (mActiveSubscriptions.size() > numberOfSubInfo) {
+                mActiveSubscriptions.remove(numberOfSubInfo);
+            }
+            when(mSubscriptionManager.getActiveSubscriptionInfoList())
+                    .thenReturn(mActiveSubscriptions);
+
+            // fetch twice and test if they generated access to SubscriptionManager only once
+            subInfoList = mListener.getActiveSubscriptionsInfo();
+            subInfoList = mListener.getActiveSubscriptionsInfo();
+
+            numberOfAccess++;
+            verify(mSubscriptionManager, times(numberOfAccess)).getActiveSubscriptionInfoList();
+
+            mListener.clearCache();
+        }
+
+        when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(null);
+
+        // fetch twice and test if they generated access to SubscriptionManager only once
+        subInfoList = mListener.getActiveSubscriptionsInfo();
+        subInfoList = mListener.getActiveSubscriptionsInfo();
+
+        numberOfAccess++;
+        verify(mSubscriptionManager, times(numberOfAccess)).getActiveSubscriptionInfoList();
+    }
+}

tests/robotests/src/com/android/settings/network/telephony/MobileNetworkActivityTest.java

@@ -16,23 +16,18 @@
 
 package com.android.settings.network.telephony;
 
-import static com.android.settings.network.telephony.MobileNetworkActivity.MOBILE_SETTINGS_TAG;
+import static androidx.lifecycle.Lifecycle.State;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
+import static org.robolectric.Shadows.shadowOf;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
-import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
+import android.os.UserManager;
 import android.provider.Settings;
 import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionInfo;
@@ -41,12 +36,14 @@ import android.telephony.TelephonyManager;
 import android.view.Menu;
 import android.view.View;
 
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
 import com.android.internal.telephony.TelephonyIntents;
-import com.android.internal.view.menu.ContextMenuBuilder;
 import com.android.settings.R;
 import com.android.settings.core.FeatureFlags;
 import com.android.settings.development.featureflags.FeatureFlagPersistent;
-import com.android.settings.network.SubscriptionUtil;
 
 import com.google.android.material.bottomnavigation.BottomNavigationView;
 
@@ -56,213 +53,193 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
-import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowContextImpl;
+import org.robolectric.shadows.ShadowSubscriptionManager;
+import org.robolectric.shadows.ShadowSubscriptionManager.SubscriptionInfoBuilder;
 
-import java.util.ArrayList;
+@RunWith(AndroidJUnit4.class)
-import java.util.Arrays;
-import java.util.List;
-
-import androidx.fragment.app.Fragment;
-import androidx.fragment.app.FragmentManager;
-import androidx.fragment.app.FragmentTransaction;
-
-@RunWith(RobolectricTestRunner.class)
 public class MobileNetworkActivityTest {
 
     private static final int CURRENT_SUB_ID = 3;
     private static final int PREV_SUB_ID = 1;
 
     private Context mContext;
-    private MobileNetworkActivity mMobileNetworkActivity;
+    private ShadowContextImpl mShadowContextImpl;
-    private List<SubscriptionInfo> mSubscriptionInfos;
+    private Intent mTestIntent;
-    private Fragment mShowFragment;
-    private Fragment mHideFragment;
 
     @Mock
-    private SubscriptionManager mSubscriptionManager;
+    private UserManager mUserManager;
     @Mock
     private TelephonyManager mTelephonyManager;
-    @Mock
+
-    private SubscriptionInfo mSubscriptionInfo;
+    private ShadowSubscriptionManager mSubscriptionManager;
-    @Mock
+    private SubscriptionInfo mSubscriptionInfo1;
     private SubscriptionInfo mSubscriptionInfo2;
-    @Mock
+
-    private FragmentManager mFragmentManager;
+    private ActivityScenario<MobileNetworkActivity> mMobileNetworkActivity;
-    @Mock
-    private FragmentTransaction mFragmentTransaction;
-    @Mock
-    private BottomNavigationView mBottomNavigationView;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mContext = spy(RuntimeEnvironment.application);
 
-        mMobileNetworkActivity = spy(new MobileNetworkActivity());
+        mContext = ApplicationProvider.getApplicationContext();
-        mSubscriptionInfos = new ArrayList<>();
+        mShadowContextImpl = Shadow.extract(RuntimeEnvironment.application.getBaseContext());
-        mShowFragment = new Fragment();
-        mHideFragment = new Fragment();
-        mMobileNetworkActivity.mSubscriptionInfos = mSubscriptionInfos;
-        mMobileNetworkActivity.mSubscriptionManager = mSubscriptionManager;
-        when(mSubscriptionInfo.getSubscriptionId()).thenReturn(PREV_SUB_ID);
-        when(mSubscriptionInfo2.getSubscriptionId()).thenReturn(CURRENT_SUB_ID);
 
-        doReturn(mSubscriptionManager).when(mMobileNetworkActivity).getSystemService(
+        mShadowContextImpl.setSystemService(Context.USER_SERVICE, mUserManager);
-                SubscriptionManager.class);
+        doReturn(true).when(mUserManager).isAdminUser();
-        doReturn(mTelephonyManager).when(mMobileNetworkActivity).getSystemService(
+
-                TelephonyManager.class);
+        mShadowContextImpl.setSystemService(Context.TELEPHONY_SERVICE, mTelephonyManager);
-        doReturn(mBottomNavigationView).when(mMobileNetworkActivity).findViewById(R.id.bottom_nav);
+        doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt());
-        doReturn(mFragmentManager).when(mMobileNetworkActivity).getSupportFragmentManager();
+
-        doReturn(mFragmentTransaction).when(mFragmentManager).beginTransaction();
+        mTestIntent = new Intent(mContext, MockMobileNetworkActivity.class);
-        doReturn(mHideFragment).when(mFragmentManager).findFragmentByTag(
+
-                MOBILE_SETTINGS_TAG + PREV_SUB_ID);
+        mSubscriptionManager = shadowOf(mContext.getSystemService(SubscriptionManager.class));
-        doReturn(mShowFragment).when(mFragmentManager).findFragmentByTag(
+        mSubscriptionInfo1 = SubscriptionInfoBuilder.newBuilder()
-                MOBILE_SETTINGS_TAG + CURRENT_SUB_ID);
+                .setId(PREV_SUB_ID).buildSubscriptionInfo();
+        mSubscriptionInfo2 = SubscriptionInfoBuilder.newBuilder()
+                .setId(CURRENT_SUB_ID).buildSubscriptionInfo();
     }
 
     @After
-    public void tearDown() {
+    public void cleanUp() {
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(null);
+        if (mMobileNetworkActivity != null) {
+            mMobileNetworkActivity.close();
+        }
+    }
+
+    private static class MockMobileNetworkActivity extends MobileNetworkActivity {
+        private MockMobileNetworkActivity() {
+            super();
+        }
+
+        private SubscriptionInfo mSubscriptionInFragment;
+
+        @Override
+        void switchFragment(SubscriptionInfo subInfo) {
+            mSubscriptionInFragment = subInfo;
+        }
+    }
+
+    private ActivityScenario<MobileNetworkActivity> createTargetActivity(Intent activityIntent,
+            boolean isInternetV2) {
+        FeatureFlagPersistent.setEnabled(mContext, FeatureFlags.NETWORK_INTERNET_V2, isInternetV2);
+        return ActivityScenario.launch(activityIntent);
     }
 
     @Test
     public void updateBottomNavigationView_oneSubscription_shouldBeGone() {
-        mSubscriptionInfos.add(mSubscriptionInfo);
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1);
-        doReturn(mSubscriptionInfos).when(mSubscriptionManager).getActiveSubscriptionInfoList(
-                eq(true));
 
-        mMobileNetworkActivity.updateBottomNavigationView();
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, false);
 
-        verify(mBottomNavigationView).setVisibility(View.GONE);
+        mMobileNetworkActivity.moveToState(State.STARTED);
+
+        mMobileNetworkActivity.onActivity(activity -> {
+            final BottomNavigationView bottomNavigationView =
+                    activity.findViewById(R.id.bottom_nav);
+            assertThat(bottomNavigationView.getVisibility()).isEqualTo(View.GONE);
+        });
+    }
+
+    @Test
+    public void updateBottomNavigationViewV2_oneSubscription_shouldNotCrash() {
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1);
+
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, true);
+
+        mMobileNetworkActivity.moveToState(State.STARTED);
     }
 
     @Test
     public void updateBottomNavigationView_twoSubscription_updateMenu() {
-        final Menu menu = new ContextMenuBuilder(mContext);
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1, mSubscriptionInfo2);
-        mSubscriptionInfos.add(mSubscriptionInfo);
-        mSubscriptionInfos.add(mSubscriptionInfo);
-        doReturn(mSubscriptionInfos).when(mSubscriptionManager).getActiveSubscriptionInfoList(
-                eq(true));
-        doReturn(menu).when(mBottomNavigationView).getMenu();
 
-        mMobileNetworkActivity.updateBottomNavigationView();
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, false);
 
+        mMobileNetworkActivity.moveToState(State.STARTED);
+
+        mMobileNetworkActivity.onActivity(activity -> {
+            final BottomNavigationView bottomNavigationView =
+                    activity.findViewById(R.id.bottom_nav);
+            final Menu menu = bottomNavigationView.getMenu();
             assertThat(menu.size()).isEqualTo(2);
+        });
     }
 
     @Test
-    public void switchFragment_newFragment_replaceIt() {
+    public void updateBottomNavigationViewV2_twoSubscription_shouldNotCrash() {
-        mMobileNetworkActivity.mCurSubscriptionId = PREV_SUB_ID;
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1, mSubscriptionInfo2);
 
-        mMobileNetworkActivity.switchFragment(mShowFragment, CURRENT_SUB_ID);
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, true);
 
-        verify(mFragmentTransaction).replace(R.id.main_content, mShowFragment,
+        mMobileNetworkActivity.moveToState(State.STARTED);
-                MOBILE_SETTINGS_TAG + CURRENT_SUB_ID);
     }
 
     @Test
-    public void phoneChangeReceiver_ignoresStickyBroadcastFromBeforeRegistering() {
+    public void switchFragment_switchBetweenTwoSubscriptions() {
-        Context activity = mContext;
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1, mSubscriptionInfo2);
-        MobileNetworkActivity.PhoneChangeReceiver.Client client = mock(
-                MobileNetworkActivity.PhoneChangeReceiver.Client.class);
-        MobileNetworkActivity.PhoneChangeReceiver receiver =
-                new MobileNetworkActivity.PhoneChangeReceiver(activity, client);
-        Intent intent = new Intent(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
-        activity.sendStickyBroadcast(intent);
 
-        receiver.register();
+        mTestIntent.putExtra(Settings.EXTRA_SUB_ID, PREV_SUB_ID);
-        verify(client, never()).onPhoneChange();
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, false);
 
-        activity.sendStickyBroadcast(intent);
+        mMobileNetworkActivity.moveToState(State.STARTED);
-        verify(client, times(1)).onPhoneChange();
+
+        mMobileNetworkActivity.onActivity(activity -> {
+            final MockMobileNetworkActivity mockActivity = (MockMobileNetworkActivity) activity;
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo1);
+
+            final BottomNavigationView bottomNavigationView =
+                    mockActivity.findViewById(R.id.bottom_nav);
+            bottomNavigationView.setSelectedItemId(CURRENT_SUB_ID);
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo2);
+
+            bottomNavigationView.setSelectedItemId(PREV_SUB_ID);
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo1);
+        });
     }
 
     @Test
-    public void phoneChangeReceiver_ignoresCarrierConfigChangeForWrongSubscriptionId() {
+    public void switchFragment_subscriptionsUpdate_notifyByIntent() {
-        Context activity = mContext;
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1, mSubscriptionInfo2);
 
-        MobileNetworkActivity.PhoneChangeReceiver.Client client = mock(
+        mTestIntent.putExtra(Settings.EXTRA_SUB_ID, PREV_SUB_ID);
-                MobileNetworkActivity.PhoneChangeReceiver.Client.class);
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, true);
-        doReturn(2).when(client).getSubscriptionId();
 
-        MobileNetworkActivity.PhoneChangeReceiver receiver =
+        mMobileNetworkActivity.moveToState(State.STARTED);
-                new MobileNetworkActivity.PhoneChangeReceiver(activity, client);
 
-        receiver.register();
+        mMobileNetworkActivity.onActivity(activity -> {
+            final MockMobileNetworkActivity mockActivity = (MockMobileNetworkActivity) activity;
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo1);
 
-        Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
+            mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo2);
-        intent.putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, 3);
+            mContext.sendBroadcast(new Intent(
-        activity.sendBroadcast(intent);
+                    CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED), null);
-        verify(client, never()).onPhoneChange();
-    }
 
-    @Test
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo2);
-    public void phoneChangeReceiver_dispatchesCarrierConfigChangeForCorrectSubscriptionId() {
-        Context activity = mContext;
 
-        MobileNetworkActivity.PhoneChangeReceiver.Client client = mock(
+            mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1);
-                MobileNetworkActivity.PhoneChangeReceiver.Client.class);
+            mContext.sendBroadcast(new Intent(
-        doReturn(2).when(client).getSubscriptionId();
+                    TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED), null);
 
-        MobileNetworkActivity.PhoneChangeReceiver receiver =
+            assertThat(mockActivity.mSubscriptionInFragment).isEqualTo(mSubscriptionInfo1);
-                new MobileNetworkActivity.PhoneChangeReceiver(activity, client);
+        });
-
-        receiver.register();
-
-        Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
-        intent.putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, 2);
-        activity.sendBroadcast(intent);
-        verify(client).onPhoneChange();
-    }
-
-
-    @Test
-    public void getSubscriptionId_hasIntent_getIdFromIntent() {
-        final Intent intent = new Intent();
-        intent.putExtra(Settings.EXTRA_SUB_ID, CURRENT_SUB_ID);
-        doReturn(intent).when(mMobileNetworkActivity).getIntent();
-        mSubscriptionInfos.add(mSubscriptionInfo);
-        mSubscriptionInfos.add(mSubscriptionInfo2);
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(mSubscriptionInfos);
-        doReturn(true).when(mSubscriptionManager).isActiveSubscriptionId(CURRENT_SUB_ID);
-
-        assertThat(mMobileNetworkActivity.getSubscriptionId()).isEqualTo(CURRENT_SUB_ID);
-    }
-
-    @Test
-    public void getSubscriptionId_noIntent_firstIdInList() {
-        doReturn(null).when(mMobileNetworkActivity).getIntent();
-        mSubscriptionInfos.add(mSubscriptionInfo);
-        mSubscriptionInfos.add(mSubscriptionInfo2);
-
-        assertThat(mMobileNetworkActivity.getSubscriptionId()).isEqualTo(PREV_SUB_ID);
     }
 
     @Test
     public void onSaveInstanceState_saveCurrentSubId() {
-        mMobileNetworkActivity = Robolectric.buildActivity(MobileNetworkActivity.class).get();
+        mSubscriptionManager.setActiveSubscriptionInfos(mSubscriptionInfo1, mSubscriptionInfo2);
-        mMobileNetworkActivity.mCurSubscriptionId = PREV_SUB_ID;
+
+        mTestIntent.putExtra(Settings.EXTRA_SUB_ID, PREV_SUB_ID);
+        mMobileNetworkActivity = createTargetActivity(mTestIntent, false);
+
+        mMobileNetworkActivity.moveToState(State.STARTED);
+
+        mMobileNetworkActivity.onActivity(activity -> {
             final Bundle bundle = new Bundle();
-
+            activity.saveInstanceState(bundle);
-        mMobileNetworkActivity.saveInstanceState(bundle);
-
             assertThat(bundle.getInt(Settings.EXTRA_SUB_ID)).isEqualTo(PREV_SUB_ID);
-    }
+        });
-
-    @Test
-    public void onNewIntent_newSubscriptionId_fragmentReplaced() {
-        FeatureFlagPersistent.setEnabled(mContext, FeatureFlags.NETWORK_INTERNET_V2, true);
-
-        mSubscriptionInfos.add(mSubscriptionInfo);
-        mSubscriptionInfos.add(mSubscriptionInfo2);
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(mSubscriptionInfos);
-        mMobileNetworkActivity.mCurSubscriptionId = PREV_SUB_ID;
-
-        final Intent newIntent = new Intent();
-        newIntent.putExtra(Settings.EXTRA_SUB_ID, CURRENT_SUB_ID);
-        mMobileNetworkActivity.onNewIntent(newIntent);
-        assertThat(mMobileNetworkActivity.mCurSubscriptionId).isEqualTo(CURRENT_SUB_ID);
     }
 }