Snap for 8050871 from b43d872018 to tm-release

Change-Id: I6d3c64f0d4f6695a64a871b8ee88aa100783dac2

res/layout/daltonizer_preview.xml

@@ -18,7 +18,9 @@
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/preview_viewport"
     android:layout_width="match_parent"
-    android:layout_height="wrap_content">
+    android:layout_height="wrap_content"
+    android:paddingStart="?android:attr/listPreferredItemPaddingStart"
+    android:paddingEnd="?android:attr/listPreferredItemPaddingEnd">
 
     <LinearLayout
         android:id="@+id/palette_view"

res/values/dimens.xml

@@ -289,6 +289,7 @@
     <dimen name="accessibility_layout_margin_start_end">16dp</dimen>
     <dimen name="accessibility_button_preference_padding_top_bottom">18dp</dimen>
     <dimen name="accessibility_imageview_size">176dp</dimen>
+    <dimen name="accessibility_illustration_view_radius">28dp</dimen>
     <!-- The margin between two Textviews-->
     <dimen name="accessibility_textview_layout_margin_bottom">24dp</dimen>
 

src/com/android/settings/accessibility/PaletteListPreference.java

@@ -148,6 +148,8 @@ public final class PaletteListPreference extends Preference {
 
             rootView.addView(textView);
         }
+
+        updateFirstAndLastItemsBackground(context, rootView, paletteData.size());
     }
 
     private GradientDrawable createGradientDrawable(ViewGroup rootView, @ColorInt int color) {
@@ -164,6 +166,19 @@ public final class PaletteListPreference extends Preference {
         return gradientDrawable;
     }
 
+    private void updateFirstAndLastItemsBackground(Context context, ViewGroup rootView, int size) {
+        final int radius =
+                context.getResources().getDimensionPixelSize(
+                        R.dimen.accessibility_illustration_view_radius);
+        final int lastIndex = size - 1;
+        final GradientDrawable firstItem =
+                (GradientDrawable) rootView.getChildAt(0).getBackground();
+        final GradientDrawable lastItem =
+                (GradientDrawable) rootView.getChildAt(lastIndex).getBackground();
+        firstItem.setCornerRadii(new float[]{radius, radius, radius, radius, 0, 0, 0, 0});
+        lastItem.setCornerRadii(new float[]{0, 0, 0, 0, radius, radius, radius, radius});
+    }
+
     private List<Integer> getPaletteColors(Context context) {
         final int[] paletteResources =
                 context.getResources().getIntArray(R.array.setting_palette_colors);

src/com/android/settings/display/BrightnessLevelPreferenceController.java

@@ -19,6 +19,7 @@ import static com.android.settingslib.display.BrightnessUtils.GAMMA_SPACE_MAX;
 import static com.android.settingslib.display.BrightnessUtils.GAMMA_SPACE_MIN;
 import static com.android.settingslib.display.BrightnessUtils.convertLinearToGammaFloat;
 
+import android.app.ActivityOptions;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
@@ -156,7 +157,11 @@ public class BrightnessLevelPreferenceController extends AbstractPreferenceContr
         final Intent intent = new Intent(ACTION_SHOW_BRIGHTNESS_DIALOG);
         intent.putExtra(SettingsBaseActivity.EXTRA_PAGE_TRANSITION_TYPE,
                 SettingsTransitionHelper.TransitionType.TRANSITION_NONE);
-        mContext.startActivity(intent);
+
+        // Start activity in the same task and pass fade animations
+        final ActivityOptions options = ActivityOptions.makeCustomAnimation(mContext,
+                android.R.anim.fade_in, android.R.anim.fade_out);
+        mContext.startActivityForResult(preference.getKey(), intent, 0, options.toBundle());
         return true;
     }
 

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

@@ -18,7 +18,6 @@ package com.android.settings.network;
 
 import android.app.FragmentManager;
 import android.app.PendingIntent;
-import android.content.Intent;
 import android.telephony.SubscriptionInfo;
 import android.telephony.SubscriptionManager;
 import android.telephony.UiccCardInfo;
@@ -106,21 +105,8 @@ public class SwitchToEuiccSubscriptionSidecar extends EuiccOperationSidecar {
             // Use INVALID_SUBSCRIPTION_ID to disable the esim profile.
             // The SimSlotMapping is ready, then to execute activate/inactivate esim.
             mIsDuringSimSlotMapping = true;
-            EuiccManager.ResultListener callback = new EuiccManager.ResultListener() {
-                @Override
-                public void onComplete(int resultCode, Intent resultIntent) {
-                    Log.i(TAG, String.format("Result code : %d;", resultCode));
-                    if (resultCode == EuiccManager.EMBEDDED_SUBSCRIPTION_RESULT_OK) {
-                        mSwitchSlotSidecar.runSwitchToEuiccSlot(getTargetSlot(), mPort,
-                                removedSubInfo);
-                    } else {
-                        setState(State.ERROR, resultCode);
-                    }
-                }
-            };
             mEuiccManager.switchToSubscription(SubscriptionManager.INVALID_SUBSCRIPTION_ID, mPort,
-                    getContext().getMainExecutor(),
+                    mCallbackIntent);
-                    callback);
         } else {
             mSwitchSlotSidecar.runSwitchToEuiccSlot(getTargetSlot(), mPort, removedSubInfo);
         }
@@ -187,19 +173,7 @@ public class SwitchToEuiccSubscriptionSidecar extends EuiccOperationSidecar {
 
     private void switchToSubscription() {
         // The SimSlotMapping is ready, then to execute activate/inactivate esim.
-        EuiccManager.ResultListener callback = new EuiccManager.ResultListener() {
+        mEuiccManager.switchToSubscription(mSubId, mPort, mCallbackIntent);
-            @Override
-            public void onComplete(int resultCode, Intent resultIntent) {
-                Log.i(TAG, String.format("Result code : %d;", resultCode));
-                if (resultCode == EuiccManager.EMBEDDED_SUBSCRIPTION_RESULT_OK) {
-                    setState(State.SUCCESS, Substate.UNUSED);
-                } else {
-                    setState(State.ERROR, resultCode);
-                }
-            }
-        };
-        mEuiccManager.switchToSubscription(mSubId, mPort, getContext().getMainExecutor(),
-                callback);
     }
 
     @Override

src/com/android/settings/security/CredentialStorage.java

@@ -86,7 +86,7 @@ public final class CredentialStorage extends FragmentActivity {
         final String action = intent.getAction();
         final UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
         if (!userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) {
-            if (ACTION_RESET.equals(action)) {
+            if (ACTION_RESET.equals(action) && checkCallerIsSelf()) {
                 new ResetDialog();
             } else {
                 if (ACTION_INSTALL.equals(action) && checkCallerIsCertInstallerOrSelfInProfile()) {
@@ -318,6 +318,19 @@ public final class CredentialStorage extends FragmentActivity {
         finish();
     }
 
+    /**
+     * Check that the caller is Settings.
+     */
+    private boolean checkCallerIsSelf() {
+        try {
+            return Process.myUid() == android.app.ActivityManager.getService()
+                    .getLaunchedFromUid(getActivityToken());
+        } catch (RemoteException re) {
+            // Error talking to ActivityManager, just give up
+            return false;
+        }
+    }
+
     /**
      * Check that the caller is either certinstaller or Settings running in a profile of this user.
      */

src/com/android/settings/wifi/WifiDialogActivity.java

@@ -105,6 +105,7 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
     private Intent mIntent;
     private NetworkDetailsTracker mNetworkDetailsTracker;
     private HandlerThread mWorkerThread;
+    private WifiManager mWifiManager;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -150,22 +151,12 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
     @Override
     protected void onStart() {
         super.onStart();
-        if (mDialog2 != null || mDialog != null) {
+        if (mDialog2 != null || mDialog != null || !hasWifiManager()) {
             return;
         }
 
         if (WizardManagerHelper.isAnySetupWizard(getIntent())) {
-            final int targetStyle = ThemeHelper.isSetupWizardDayNightEnabled(this)
+            createDialogWithSuwTheme();
-                    ? R.style.SuwAlertDialogThemeCompat_DayNight :
-                    R.style.SuwAlertDialogThemeCompat_Light;
-            if (mIsWifiTrackerLib) {
-                mDialog2 = WifiDialog2.createModal(this, this,
-                        mNetworkDetailsTracker.getWifiEntry(),
-                        WifiConfigUiBase2.MODE_CONNECT, targetStyle);
-            } else {
-                mDialog = WifiDialog.createModal(this, this, mAccessPoint,
-                        WifiConfigUiBase.MODE_CONNECT, targetStyle);
-            }
         } else {
             if (mIsWifiTrackerLib) {
                 mDialog2 = WifiDialog2.createModal(this, this,
@@ -177,11 +168,30 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
         }
 
         if (mIsWifiTrackerLib) {
-            mDialog2.show();
+            if (mDialog2 != null) {
-            mDialog2.setOnDismissListener(this);
+                mDialog2.show();
+                mDialog2.setOnDismissListener(this);
+            }
         } else {
-            mDialog.show();
+            if (mDialog != null) {
-            mDialog.setOnDismissListener(this);
+                mDialog.show();
+                mDialog.setOnDismissListener(this);
+            }
+        }
+    }
+
+    @VisibleForTesting
+    protected void createDialogWithSuwTheme() {
+        final int targetStyle = ThemeHelper.isSetupWizardDayNightEnabled(this)
+                ? R.style.SuwAlertDialogThemeCompat_DayNight :
+                R.style.SuwAlertDialogThemeCompat_Light;
+        if (mIsWifiTrackerLib) {
+            mDialog2 = WifiDialog2.createModal(this, this,
+                    mNetworkDetailsTracker.getWifiEntry(),
+                    WifiConfigUiBase2.MODE_CONNECT, targetStyle);
+        } else {
+            mDialog = WifiDialog.createModal(this, this, mAccessPoint,
+                    WifiConfigUiBase.MODE_CONNECT, targetStyle);
         }
     }
 
@@ -221,21 +231,21 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
 
     @Override
     public void onForget(WifiDialog dialog) {
-        final WifiManager wifiManager = getSystemService(WifiManager.class);
+        if (!hasWifiManager()) return;
         final AccessPoint accessPoint = dialog.getController().getAccessPoint();
         if (accessPoint != null) {
             if (!accessPoint.isSaved()) {
                 if (accessPoint.getNetworkInfo() != null &&
                         accessPoint.getNetworkInfo().getState() != NetworkInfo.State.DISCONNECTED) {
                     // Network is active but has no network ID - must be ephemeral.
-                    wifiManager.disableEphemeralNetwork(
+                    mWifiManager.disableEphemeralNetwork(
                             AccessPoint.convertToQuotedString(accessPoint.getSsidStr()));
                 } else {
                     // Should not happen, but a monkey seems to trigger it
                     Log.e(TAG, "Failed to forget invalid network " + accessPoint.getConfig());
                 }
             } else {
-                wifiManager.forget(accessPoint.getConfig().networkId, null /* listener */);
+                mWifiManager.forget(accessPoint.getConfig().networkId, null /* listener */);
             }
         }
 
@@ -251,6 +261,7 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
 
     @Override
     public void onSubmit(WifiDialog2 dialog) {
+        if (!hasWifiManager()) return;
         final WifiEntry wifiEntry = dialog.getController().getWifiEntry();
         final WifiConfiguration config = dialog.getController().getConfig();
 
@@ -258,7 +269,7 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
             if (config == null && wifiEntry != null && wifiEntry.canConnect()) {
                 wifiEntry.connect(null /* callback */);
             } else {
-                getSystemService(WifiManager.class).connect(config, null /* listener */);
+                mWifiManager.connect(config, null /* listener */);
             }
         }
 
@@ -269,22 +280,22 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
 
     @Override
     public void onSubmit(WifiDialog dialog) {
+        if (!hasWifiManager()) return;
         final WifiConfiguration config = dialog.getController().getConfig();
         final AccessPoint accessPoint = dialog.getController().getAccessPoint();
-        final WifiManager wifiManager = getSystemService(WifiManager.class);
 
         if (getIntent().getBooleanExtra(KEY_CONNECT_FOR_CALLER, true)) {
             if (config == null) {
                 if (accessPoint != null && accessPoint.isSaved()) {
-                    wifiManager.connect(accessPoint.getConfig(), null /* listener */);
+                    mWifiManager.connect(accessPoint.getConfig(), null /* listener */);
                 }
             } else {
-                wifiManager.save(config, null /* listener */);
+                mWifiManager.save(config, null /* listener */);
                 if (accessPoint != null) {
                     // accessPoint is null for "Add network"
                     NetworkInfo networkInfo = accessPoint.getNetworkInfo();
                     if (networkInfo == null || !networkInfo.isConnected()) {
-                        wifiManager.connect(config, null /* listener */);
+                        mWifiManager.connect(config, null /* listener */);
                     }
                 }
             }
@@ -350,6 +361,12 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
         }
     }
 
+    private boolean hasWifiManager() {
+        if (mWifiManager != null) return true;
+        mWifiManager = getSystemService(WifiManager.class);
+        return (mWifiManager != null);
+    }
+
     protected boolean hasPermissionForResult() {
         final String callingPackage = getCallingPackage();
         if (callingPackage == null) {

tests/robotests/src/com/android/settings/wifi/WifiDialogActivityTest.java

@@ -26,7 +26,8 @@ import static com.android.settings.wifi.WifiDialogActivity.RESULT_OK;
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -36,41 +37,25 @@ import android.content.pm.PackageManager;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
 
-import androidx.lifecycle.Lifecycle.State;
+import com.android.settings.testutils.FakeFeatureFactory;
-import androidx.test.core.app.ActivityScenario;
-
-import com.android.settings.R;
-import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
-import com.android.settings.testutils.shadow.ShadowConnectivityManager;
-import com.android.settings.testutils.shadow.ShadowNetworkDetailsTracker;
-import com.android.settings.testutils.shadow.ShadowWifiManager;
 import com.android.settingslib.wifi.AccessPoint;
+import com.android.wifitrackerlib.WifiEntry;
 
 import com.google.android.setupcompat.util.WizardManagerHelper;
 
-import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
 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.annotation.Config;
-import org.robolectric.util.ReflectionHelpers;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
-        ShadowAlertDialogCompat.class,
-        ShadowConnectivityManager.class,
-        ShadowNetworkDetailsTracker.class,
-        ShadowWifiManager.class
-})
 public class WifiDialogActivityTest {
 
-    private static final String CALLING_PACKAGE = "calling_package";
+    static final String CALLING_PACKAGE = "calling_package";
-    private static final String AP1_SSID = "\"ap1\"";
+    static final int REQUEST_CODE = REQUEST_CODE_WIFI_DPP_ENROLLEE_QR_CODE_SCANNER;
 
     @Mock
     PackageManager mPackageManager;
@@ -87,13 +72,13 @@ public class WifiDialogActivityTest {
     @Mock
     WifiConfigController2 mWifiConfiguration2;
     @Mock
+    WifiEntry mWifiEntry;
+    @Mock
     Intent mResultData;
     @Mock
-    private WifiConfigController mController;
+    WifiConfigController mController;
-    @Mock
-    private WifiConfigController2 mController2;
 
-    private ActivityScenario<WifiDialogActivity> mWifiDialogActivity;
+    WifiDialogActivity mActivity;
 
     @Before
     public void setUp() {
@@ -102,254 +87,190 @@ public class WifiDialogActivityTest {
         when(mController.getConfig()).thenReturn(mWifiConfiguration);
         when(mController.getAccessPoint()).thenReturn(mAccessPoint);
         when(mWifiDialog2.getController()).thenReturn(mWifiConfiguration2);
+        when(mWifiConfiguration2.getWifiEntry()).thenReturn(mWifiEntry);
+        when(mWifiEntry.canConnect()).thenReturn(true);
+        FakeFeatureFactory.setupForTest();
 
-        WifiConfiguration wifiConfig = new WifiConfiguration();
+        mActivity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
-        wifiConfig.SSID = AP1_SSID;
+        when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
-        doReturn(wifiConfig).when(mController).getConfig();
-        doReturn(wifiConfig).when(mController2).getConfig();
-    }
-
-    @After
-    public void cleanUp() {
-        if (mWifiDialogActivity != null) {
-            mWifiDialogActivity.close();
-        }
-    }
-
-    private ActivityScenario<WifiDialogActivity> createTargetActivity(Intent activityIntent) {
-        return ActivityScenario.launch(activityIntent);
     }
 
     @Test
     public void onSubmit_shouldConnectToNetwork() {
-        WifiDialogActivity activity = Robolectric.setupActivity(WifiDialogActivity.class);
+        mActivity.onSubmit(mWifiDialog);
-        WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
-        assertThat(dialog).isNotNull();
 
-        ReflectionHelpers.setField(dialog, "mController", mController);
+        verify(mWifiManager).connect(any(), any());
-
-        activity.onSubmit(dialog);
-
-        assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP1_SSID);
     }
 
     @Test
     public void onSubmit_noPermissionForResult_setResultWithoutData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(false);
-        when(activity.hasPermissionForResult()).thenReturn(false);
-        when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        activity.onSubmit(mWifiDialog);
+        mActivity.onSubmit(mWifiDialog);
 
-        verify(activity).setResult(RESULT_CONNECTED, null);
+        verify(mActivity).setResult(RESULT_CONNECTED, null);
     }
 
     @Test
     public void onSubmit_hasPermissionForResult_setResultWithData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(true);
-        when(activity.hasPermissionForResult()).thenReturn(true);
+        when(mActivity.createResultData(any(), any())).thenReturn(mResultData);
-        when(activity.createResultData(any(), any())).thenReturn(mResultData);
-        when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        activity.onSubmit(mWifiDialog);
+        mActivity.onSubmit(mWifiDialog);
 
-        verify(activity).setResult(RESULT_CONNECTED, mResultData);
+        verify(mActivity).setResult(RESULT_CONNECTED, mResultData);
     }
 
     @Test
     public void onSubmit2_noPermissionForResult_setResultWithoutData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(false);
-        when(activity.hasPermissionForResult()).thenReturn(false);
-        when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        activity.onSubmit(mWifiDialog2);
+        mActivity.onSubmit(mWifiDialog2);
 
-        verify(activity).setResult(RESULT_CONNECTED, null);
+        verify(mActivity).setResult(RESULT_CONNECTED, null);
     }
 
     @Test
     public void onSubmit2_hasPermissionForResult_setResultWithData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(true);
-        when(activity.hasPermissionForResult()).thenReturn(true);
+        when(mActivity.createResultData(any(), any())).thenReturn(mResultData);
-        when(activity.createResultData(any(), any())).thenReturn(mResultData);
-        when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        activity.onSubmit(mWifiDialog2);
+        mActivity.onSubmit(mWifiDialog2);
 
-        verify(activity).setResult(RESULT_CONNECTED, mResultData);
+        verify(mActivity).setResult(RESULT_CONNECTED, mResultData);
     }
 
     @Test
-    @Ignore
     public void onSubmit2_whenConnectForCallerIsTrue_shouldConnectToNetwork() {
         final Intent intent = new Intent("com.android.settings.WIFI_DIALOG");
         intent.putExtra(WifiDialogActivity.KEY_CHOSEN_WIFIENTRY_KEY, "FAKE_KEY");
         intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, true);
-        mWifiDialogActivity = createTargetActivity(intent);
+        mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
+        when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        mWifiDialogActivity.moveToState(State.CREATED);
+        mActivity.onSubmit(mWifiDialog2);
-        mWifiDialogActivity.moveToState(State.STARTED);
 
-        WifiDialog2 dialog = (WifiDialog2) ShadowAlertDialogCompat.getLatestAlertDialog();
+        verify(mWifiEntry).connect(any());
-        assertThat(dialog).isNotNull();
-
-        ReflectionHelpers.setField(dialog, "mController", mController2);
-
-        mWifiDialogActivity.onActivity(activity -> {
-            activity.onSubmit(dialog);
-            assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP1_SSID);
-        });
     }
 
     @Test
     public void onSubmit_whenConnectForCallerIsFalse_shouldNotConnectToNetwork() {
-        WifiDialogActivity activity =
+        final Intent intent = new Intent();
-                Robolectric.buildActivity(
+        intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false);
-                        WifiDialogActivity.class,
+        mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
-                        new Intent().putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false))
+        when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
-                        .setup().get();
-        WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
 
-        assertThat(dialog).isNotNull();
+        mActivity.onSubmit(mWifiDialog);
 
-        ReflectionHelpers.setField(dialog, "mController", mController);
+        verify(mWifiManager, never()).connect(any(), any());
-
-        activity.onSubmit(dialog);
-
-        assertThat(ShadowWifiManager.get().savedWifiConfig).isNull();
     }
 
     @Test
-    @Ignore
     public void onSubmit2_whenConnectForCallerIsFalse_shouldNotConnectToNetwork() {
         final Intent intent = new Intent("com.android.settings.WIFI_DIALOG");
         intent.putExtra(WifiDialogActivity.KEY_CHOSEN_WIFIENTRY_KEY, "FAKE_KEY");
         intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false);
-        mWifiDialogActivity = createTargetActivity(intent);
+        mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
+        when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
 
-        mWifiDialogActivity.moveToState(State.CREATED);
+        mActivity.onSubmit(mWifiDialog2);
-        mWifiDialogActivity.moveToState(State.STARTED);
 
-        WifiDialog2 dialog = (WifiDialog2) ShadowAlertDialogCompat.getLatestAlertDialog();
+        verify(mWifiEntry, never()).connect(any());
-        assertThat(dialog).isNotNull();
-
-        ReflectionHelpers.setField(dialog, "mController", mController2);
-
-        mWifiDialogActivity.onActivity(activity -> {
-            activity.onSubmit(dialog);
-            assertThat(ShadowWifiManager.get().savedWifiConfig).isEqualTo(null);
-        });
     }
 
     @Test
-    public void onSubmit_whenLaunchInSetupFlow_shouldBeLightThemeForWifiDialog() {
+    public void onStart_whenLaunchInSetupFlow_shouldCreateDialogWithSuwTheme() {
-        WifiDialogActivity activity =
+        final Intent intent = new Intent();
-                Robolectric.buildActivity(
+        intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false);
-                        WifiDialogActivity.class,
+        intent.putExtra(WizardManagerHelper.EXTRA_IS_FIRST_RUN, true);
-                        new Intent()
+        intent.putExtra(WizardManagerHelper.EXTRA_IS_SETUP_FLOW, true);
-                                .putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false)
+        mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
-                                .putExtra(WizardManagerHelper.EXTRA_IS_FIRST_RUN, true)
+        when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
-                                .putExtra(WizardManagerHelper.EXTRA_IS_SETUP_FLOW, true))
+        doNothing().when(mActivity).createDialogWithSuwTheme();
-                        .setup().get();
-        WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
 
-        assertThat(dialog).isNotNull();
+        mActivity.onStart();
 
-        activity.onSubmit(dialog);
+        verify(mActivity).createDialogWithSuwTheme();
-
-        assertThat(dialog.getContext().getThemeResId())
-                .isEqualTo(R.style.SuwAlertDialogThemeCompat_Light);
     }
 
     @Test
     public void onActivityResult_noPermissionForResult_setResultWithoutData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(false);
-        when(activity.hasPermissionForResult()).thenReturn(false);
-        final Intent data = new Intent();
 
-        activity.onActivityResult(REQUEST_CODE_WIFI_DPP_ENROLLEE_QR_CODE_SCANNER, RESULT_OK,
+        mActivity.onActivityResult(REQUEST_CODE, RESULT_OK, mResultData);
-                data);
 
-        verify(activity).setResult(RESULT_CONNECTED);
+        verify(mActivity).setResult(RESULT_CONNECTED);
     }
 
     @Test
     public void onActivityResult_hasPermissionForResult_setResultWithData() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.hasPermissionForResult()).thenReturn(true);
-        when(activity.hasPermissionForResult()).thenReturn(true);
-        final Intent data = new Intent();
 
-        activity.onActivityResult(REQUEST_CODE_WIFI_DPP_ENROLLEE_QR_CODE_SCANNER, RESULT_OK,
+        mActivity.onActivityResult(REQUEST_CODE, RESULT_OK, mResultData);
-                data);
 
-        verify(activity).setResult(RESULT_CONNECTED, data);
+        verify(mActivity).setResult(RESULT_CONNECTED, mResultData);
     }
 
     @Test
     public void hasPermissionForResult_noCallingPackage_returnFalse() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.getCallingPackage()).thenReturn(null);
-        when(activity.getCallingPackage()).thenReturn(null);
 
-        final boolean result = activity.hasPermissionForResult();
+        final boolean result = mActivity.hasPermissionForResult();
 
         assertThat(result).isFalse();
     }
 
     @Test
     public void hasPermissionForResult_noPermission_returnFalse() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.getCallingPackage()).thenReturn(null);
-        when(activity.getCallingPackage()).thenReturn(null);
         when(mPackageManager.checkPermission(ACCESS_COARSE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_DENIED);
         when(mPackageManager.checkPermission(ACCESS_FINE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_DENIED);
 
-        final boolean result = activity.hasPermissionForResult();
+        final boolean result = mActivity.hasPermissionForResult();
 
         assertThat(result).isFalse();
     }
 
     @Test
     public void hasPermissionForResult_hasCoarseLocationPermission_returnFalse() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
-        when(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
+        when(mActivity.getPackageManager()).thenReturn(mPackageManager);
-        when(activity.getPackageManager()).thenReturn(mPackageManager);
         when(mPackageManager.checkPermission(ACCESS_COARSE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_GRANTED);
         when(mPackageManager.checkPermission(ACCESS_FINE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_DENIED);
 
-        final boolean result = activity.hasPermissionForResult();
+        final boolean result = mActivity.hasPermissionForResult();
 
         assertThat(result).isFalse();
     }
 
     @Test
     public void hasPermissionForResult_hasFineLocationPermission_returnTrue() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
-        when(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
+        when(mActivity.getPackageManager()).thenReturn(mPackageManager);
-        when(activity.getPackageManager()).thenReturn(mPackageManager);
         when(mPackageManager.checkPermission(ACCESS_COARSE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_DENIED);
         when(mPackageManager.checkPermission(ACCESS_FINE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_GRANTED);
 
-        final boolean result = activity.hasPermissionForResult();
+        final boolean result = mActivity.hasPermissionForResult();
 
         assertThat(result).isTrue();
     }
 
     @Test
     public void hasPermissionForResult_haveBothLocationPermissions_returnTrue() {
-        WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
+        when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
-        when(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
+        when(mActivity.getPackageManager()).thenReturn(mPackageManager);
-        when(activity.getPackageManager()).thenReturn(mPackageManager);
         when(mPackageManager.checkPermission(ACCESS_COARSE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_GRANTED);
         when(mPackageManager.checkPermission(ACCESS_FINE_LOCATION, CALLING_PACKAGE))
                 .thenReturn(PackageManager.PERMISSION_GRANTED);
 
-        final boolean result = activity.hasPermissionForResult();
+        final boolean result = mActivity.hasPermissionForResult();
 
         assertThat(result).isTrue();
     }