PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Snap for 8050871 from b43d872018 to tm-release

Browse Source 
Change-Id: I6d3c64f0d4f6695a64a871b8ee88aa100783dac2
This commit is contained in:
Android Build Coastguard Worker
2022-01-07 02:09:19 +00:00
parent c812ffb71e b43d872018
commit 0122dbd1bb
8 changed files with 156 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
res/layout/daltonizer_preview.xml
View File

@@ -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"

1
res/values/dimens.xml
View File

@@ -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>

15
src/com/android/settings/accessibility/PaletteListPreference.java
View File

@@ -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);

7
src/com/android/settings/display/BrightnessLevelPreferenceController.java
View File

@@ -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;
}

30
src/com/android/settings/network/SwitchToEuiccSubscriptionSidecar.java
View File

@@ -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(),
callback);
mCallbackIntent);
} 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() {
@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);
mEuiccManager.switchToSubscription(mSubId, mPort, mCallbackIntent);
}
@Override

15
src/com/android/settings/security/CredentialStorage.java
View File

@@ -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.
*/

65
src/com/android/settings/wifi/WifiDialogActivity.java
View File

@@ -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)
? 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);
}
createDialogWithSuwTheme();
} else {
if (mIsWifiTrackerLib) {
mDialog2 = WifiDialog2.createModal(this, this,
@@ -177,11 +168,30 @@ public class WifiDialogActivity extends ObservableActivity implements WifiDialog
}
if (mIsWifiTrackerLib) {
mDialog2.show();
mDialog2.setOnDismissListener(this);
if (mDialog2 != null) {
mDialog2.show();
mDialog2.setOnDismissListener(this);
}
} else {
mDialog.show();
mDialog.setOnDismissListener(this);
if (mDialog != null) {
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) {

227
tests/robotests/src/com/android/settings/wifi/WifiDialogActivityTest.java
View File

@@ -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 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.settings.testutils.FakeFeatureFactory;
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";
private static final String AP1_SSID = "\"ap1\"";
static final String CALLING_PACKAGE = "calling_package";
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;
@Mock
private WifiConfigController2 mController2;
WifiConfigController mController;
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();
wifiConfig.SSID = AP1_SSID;
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);
mActivity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
}
@Test
public void onSubmit_shouldConnectToNetwork() {
WifiDialogActivity activity = Robolectric.setupActivity(WifiDialogActivity.class);
WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
assertThat(dialog).isNotNull();
mActivity.onSubmit(mWifiDialog);
ReflectionHelpers.setField(dialog, "mController", mController);
activity.onSubmit(dialog);
assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP1_SSID);
verify(mWifiManager).connect(any(), any());
}
@Test
public void onSubmit_noPermissionForResult_setResultWithoutData() {
WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
when(activity.hasPermissionForResult()).thenReturn(false);
when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
when(mActivity.hasPermissionForResult()).thenReturn(false);
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(activity.hasPermissionForResult()).thenReturn(true);
when(activity.createResultData(any(), any())).thenReturn(mResultData);
when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
when(mActivity.hasPermissionForResult()).thenReturn(true);
when(mActivity.createResultData(any(), any())).thenReturn(mResultData);
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(activity.hasPermissionForResult()).thenReturn(false);
when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
when(mActivity.hasPermissionForResult()).thenReturn(false);
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(activity.hasPermissionForResult()).thenReturn(true);
when(activity.createResultData(any(), any())).thenReturn(mResultData);
when(activity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
when(mActivity.hasPermissionForResult()).thenReturn(true);
when(mActivity.createResultData(any(), any())).thenReturn(mResultData);
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);
mWifiDialogActivity.moveToState(State.STARTED);
mActivity.onSubmit(mWifiDialog2);
WifiDialog2 dialog = (WifiDialog2) ShadowAlertDialogCompat.getLatestAlertDialog();
assertThat(dialog).isNotNull();
ReflectionHelpers.setField(dialog, "mController", mController2);
mWifiDialogActivity.onActivity(activity -> {
activity.onSubmit(dialog);
assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP1_SSID);
});
verify(mWifiEntry).connect(any());
}
@Test
public void onSubmit_whenConnectForCallerIsFalse_shouldNotConnectToNetwork() {
WifiDialogActivity activity =
Robolectric.buildActivity(
WifiDialogActivity.class,
new Intent().putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false))
.setup().get();
WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
final Intent intent = new Intent();
intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false);
mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
assertThat(dialog).isNotNull();
mActivity.onSubmit(mWifiDialog);
ReflectionHelpers.setField(dialog, "mController", mController);
activity.onSubmit(dialog);
assertThat(ShadowWifiManager.get().savedWifiConfig).isNull();
verify(mWifiManager, never()).connect(any(), any());
}
@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);
mWifiDialogActivity.moveToState(State.STARTED);
mActivity.onSubmit(mWifiDialog2);
WifiDialog2 dialog = (WifiDialog2) ShadowAlertDialogCompat.getLatestAlertDialog();
assertThat(dialog).isNotNull();
ReflectionHelpers.setField(dialog, "mController", mController2);
mWifiDialogActivity.onActivity(activity -> {
activity.onSubmit(dialog);
assertThat(ShadowWifiManager.get().savedWifiConfig).isEqualTo(null);
});
verify(mWifiEntry, never()).connect(any());
}
@Test
public void onSubmit_whenLaunchInSetupFlow_shouldBeLightThemeForWifiDialog() {
WifiDialogActivity activity =
Robolectric.buildActivity(
WifiDialogActivity.class,
new Intent()
.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false)
.putExtra(WizardManagerHelper.EXTRA_IS_FIRST_RUN, true)
.putExtra(WizardManagerHelper.EXTRA_IS_SETUP_FLOW, true))
.setup().get();
WifiDialog dialog = (WifiDialog) ShadowAlertDialogCompat.getLatestAlertDialog();
public void onStart_whenLaunchInSetupFlow_shouldCreateDialogWithSuwTheme() {
final Intent intent = new Intent();
intent.putExtra(WifiDialogActivity.KEY_CONNECT_FOR_CALLER, false);
intent.putExtra(WizardManagerHelper.EXTRA_IS_FIRST_RUN, true);
intent.putExtra(WizardManagerHelper.EXTRA_IS_SETUP_FLOW, true);
mActivity = spy(Robolectric.buildActivity(WifiDialogActivity.class, intent).setup().get());
when(mActivity.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
doNothing().when(mActivity).createDialogWithSuwTheme();
assertThat(dialog).isNotNull();
mActivity.onStart();
activity.onSubmit(dialog);
assertThat(dialog.getContext().getThemeResId())
.isEqualTo(R.style.SuwAlertDialogThemeCompat_Light);
verify(mActivity).createDialogWithSuwTheme();
}
@Test
public void onActivityResult_noPermissionForResult_setResultWithoutData() {
WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
when(activity.hasPermissionForResult()).thenReturn(false);
final Intent data = new Intent();
when(mActivity.hasPermissionForResult()).thenReturn(false);
activity.onActivityResult(REQUEST_CODE_WIFI_DPP_ENROLLEE_QR_CODE_SCANNER, RESULT_OK,
data);
mActivity.onActivityResult(REQUEST_CODE, RESULT_OK, mResultData);
verify(activity).setResult(RESULT_CONNECTED);
verify(mActivity).setResult(RESULT_CONNECTED);
}
@Test
public void onActivityResult_hasPermissionForResult_setResultWithData() {
WifiDialogActivity activity = spy(Robolectric.setupActivity(WifiDialogActivity.class));
when(activity.hasPermissionForResult()).thenReturn(true);
final Intent data = new Intent();
when(mActivity.hasPermissionForResult()).thenReturn(true);
activity.onActivityResult(REQUEST_CODE_WIFI_DPP_ENROLLEE_QR_CODE_SCANNER, RESULT_OK,
data);
mActivity.onActivityResult(REQUEST_CODE, RESULT_OK, mResultData);
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(activity.getCallingPackage()).thenReturn(null);
when(mActivity.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(activity.getCallingPackage()).thenReturn(null);
when(mActivity.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(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(activity.getPackageManager()).thenReturn(mPackageManager);
when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(mActivity.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(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(activity.getPackageManager()).thenReturn(mPackageManager);
when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(mActivity.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(activity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(activity.getPackageManager()).thenReturn(mPackageManager);
when(mActivity.getCallingPackage()).thenReturn(CALLING_PACKAGE);
when(mActivity.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();
}