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

Introduce FirmwareVersionDialogController

Browse Source 
- Create a controller to display data and handle user input for the
 Android Version field in FirmwareVersionDialogFragment

Bug: 36458278
Test: make RunSettingsRoboTests -j40
Change-Id: Iabd46505103711451001a9374906188c707be548
This commit is contained in:
jeffreyhuang
2017-11-02 15:46:43 -07:00
parent a414573d62
commit 799c777f67
3 changed files with 241 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/com/android/settings/deviceinfo/firmwareversion/FirmwareVersionDialogController.java Normal file
View File

@@ -0,0 +1,112 @@
/*
* Copyright (C) 2017 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.deviceinfo.firmwareversion;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.UserManager;
import android.support.annotation.VisibleForTesting;
import android.util.Log;
import android.view.View;
import com.android.settings.R;
import com.android.settingslib.RestrictedLockUtils;
public class FirmwareVersionDialogController implements View.OnClickListener {
private static final String TAG = "firmwareDialogCtrl";
private static final int DELAY_TIMER_MILLIS = 500;
private static final int ACTIVITY_TRIGGER_COUNT = 3;
@VisibleForTesting
static final int FIRMWARE_VERSION_VALUE_ID = R.id.firmware_version_value;
@VisibleForTesting
static final int FIRMWARE_VERSION_LABEL_ID = R.id.firmware_version_label;
private final FirmwareVersionDialogFragment mDialog;
private final Context mContext;
private final UserManager mUserManager;
private final long[] mHits = new long[ACTIVITY_TRIGGER_COUNT];
private RestrictedLockUtils.EnforcedAdmin mFunDisallowedAdmin;
private boolean mFunDisallowedBySystem;
public FirmwareVersionDialogController(FirmwareVersionDialogFragment dialog) {
mDialog = dialog;
mContext = dialog.getContext();
mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
}
@Override
public void onClick(View v) {
arrayCopy();
mHits[mHits.length - 1] = SystemClock.uptimeMillis();
if (mHits[0] >= (SystemClock.uptimeMillis() - DELAY_TIMER_MILLIS)) {
if (mUserManager.hasUserRestriction(UserManager.DISALLOW_FUN)) {
if (mFunDisallowedAdmin != null && !mFunDisallowedBySystem) {
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(mContext,
mFunDisallowedAdmin);
}
Log.d(TAG, "Sorry, no fun for you!");
return;
}
final Intent intent = new Intent(Intent.ACTION_MAIN)
.setClassName(
"android", com.android.internal.app.PlatLogoActivity.class.getName());
try {
mContext.startActivity(intent);
} catch (Exception e) {
Log.e(TAG, "Unable to start activity " + intent.toString());
}
}
}
/**
* Populates the Android version field in the dialog and registers click listeners.
*/
public void initialize() {
initializeAdminPermissions();
registerClickListeners();
mDialog.setText(FIRMWARE_VERSION_VALUE_ID, Build.VERSION.RELEASE);
}
private void registerClickListeners() {
mDialog.registerClickListener(FIRMWARE_VERSION_LABEL_ID, this /* listener */);
mDialog.registerClickListener(FIRMWARE_VERSION_VALUE_ID, this /* listener */);
}
/**
* Copies the array onto itself to remove the oldest hit.
*/
@VisibleForTesting
void arrayCopy() {
System.arraycopy(mHits, 1, mHits, 0, mHits.length - 1);
}
@VisibleForTesting
void initializeAdminPermissions() {
mFunDisallowedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(
mContext, UserManager.DISALLOW_FUN, UserHandle.myUserId());
mFunDisallowedBySystem = RestrictedLockUtils.hasBaseUserRestriction(
mContext, UserManager.DISALLOW_FUN, UserHandle.myUserId());
}
}

27
src/com/android/settings/deviceinfo/firmwareversion/FirmwareVersionDialogFragment.java
View File

@@ -23,6 +23,7 @@ import android.app.FragmentManager;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.TextView;
import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
@@ -32,6 +33,8 @@ public class FirmwareVersionDialogFragment extends InstrumentedDialogFragment {
private static final String TAG = "firmwareVersionDialog";
private View mRootView;
public static void show(Fragment host) {
final FragmentManager manager = host.getChildFragmentManager();
if (manager.findFragmentByTag(TAG) == null) {
@@ -51,9 +54,29 @@ public class FirmwareVersionDialogFragment extends InstrumentedDialogFragment {
.setTitle(R.string.firmware_title)
.setPositiveButton(android.R.string.ok, null /* listener */);
final View view = LayoutInflater.from(getActivity()).inflate(
mRootView = LayoutInflater.from(getActivity()).inflate(
R.layout.dialog_firmware_version, null /* parent */);
return builder.setView(view).create();
initializeControllers();
return builder.setView(mRootView).create();
}
public void setText(int viewId, CharSequence text) {
final TextView view = mRootView.findViewById(viewId);
if (view != null) {
view.setText(text);
}
}
public void registerClickListener(int viewId, View.OnClickListener listener) {
final View view = mRootView.findViewById(viewId);
if (view != null) {
view.setOnClickListener(listener);
}
}
private void initializeControllers() {
new FirmwareVersionDialogController(this).initialize();
}
}

104
tests/robotests/src/com/android/settings/deviceinfo/firmwareversion/FirmwareVersionDialogControllerTest.java Normal file
View File

@@ -0,0 +1,104 @@
/*
* Copyright (C) 2017 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.deviceinfo.firmwareversion;
import static com.android.settings.deviceinfo.firmwareversion.FirmwareVersionDialogController
.FIRMWARE_VERSION_LABEL_ID;
import static com.android.settings.deviceinfo.firmwareversion.FirmwareVersionDialogController
.FIRMWARE_VERSION_VALUE_ID;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
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;
import android.content.Context;
import android.os.Build;
import android.os.UserManager;
import android.view.View;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
public class FirmwareVersionDialogControllerTest {
@Mock
private UserManager mUserManager;
@Mock
private FirmwareVersionDialogFragment mDialog;
@Mock
private View mView;
private Context mContext;
private FirmwareVersionDialogController mController;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
when(mDialog.getContext()).thenReturn(mContext);
mController = spy(new FirmwareVersionDialogController(mDialog));
ReflectionHelpers.setField(mController, "mUserManager", mUserManager);
doNothing().when(mController).arrayCopy();
doNothing().when(mController).initializeAdminPermissions();
}
@Test
public void initialize_shouldRegisterListenersAndSetBuildVersion() {
mController.initialize();
verify(mDialog).registerClickListener(eq(FIRMWARE_VERSION_VALUE_ID), any());
verify(mDialog).registerClickListener(eq(FIRMWARE_VERSION_LABEL_ID), any());
verify(mDialog).setText(FIRMWARE_VERSION_VALUE_ID, Build.VERSION.RELEASE);
}
@Test
public void handleSettingClicked_userRestricted_shouldDoNothing() {
final long[] hits = ReflectionHelpers.getField(mController, "mHits");
hits[0] = Long.MAX_VALUE;
when(mUserManager.hasUserRestriction(UserManager.DISALLOW_FUN)).thenReturn(true);
mController.onClick(mView);
verify(mContext, never()).startActivity(any());
}
@Test
public void handleSettingClicked_userNotRestricted_shouldStartActivity() {
final long[] hits = ReflectionHelpers.getField(mController, "mHits");
hits[0] = Long.MAX_VALUE;
when(mUserManager.hasUserRestriction(UserManager.DISALLOW_FUN)).thenReturn(false);
mController.onClick(mView);
verify(mContext).startActivity(any());
}
}