<!-- Warning when activating the automatic storage manager on legacy devices. [CHAR LIMIT=NONE] -->
<string name="automatic_storage_manager_activation_warning">Your storage is now being managed by the storage manager</string>
+
+ <!-- Accounts for section header [CHAR LIMIT=30] -->
+ <string name="account_for_section_header">Accounts</string>
+
+ <!-- Configure section header [CHAR LIMIT=30] -->
+ <string name="configure_section_header">Configure</string>
+
</resources>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 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.
+-->
+
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:settings="http://schemas.android.com/apk/res/com.android.settings"
+ android:key="account"
+ android:title="@string/account_settings_title"
+ settings:keywords="@string/keywords_accounts">
+
+ <PreferenceCategory
+ android:key="account_for_header"
+ android:title="@string/account_for_section_header" />
+
+ <Preference
+ android:key="emergency_info"
+ android:title="@string/emergency_info_title" />
+
+ <PreferenceCategory
+ android:key="account_configuration_header"
+ android:title="@string/configure_section_header">
+
+ <com.android.settingslib.RestrictedSwitchPreference
+ android:key="add_users_when_locked"
+ android:title="@string/user_add_on_lockscreen_menu"
+ android:summary="@string/user_add_on_lockscreen_menu_summary"
+ settings:useAdditionalSummary="true" />
+
+ </PreferenceCategory>
+
+</PreferenceScreen>
--- /dev/null
+/*
+ * Copyright (C) 2016 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.accounts;
+
+import android.content.Context;
+import android.provider.Settings.Global;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.PreferenceController;
+import com.android.settings.core.lifecycle.LifecycleObserver;
+import com.android.settings.core.lifecycle.events.OnPause;
+import com.android.settings.core.lifecycle.events.OnResume;
+import com.android.settings.users.UserCapabilities;
+import com.android.settingslib.RestrictedSwitchPreference;
+
+public class AddUserWhenLockedPreferenceController extends PreferenceController
+ implements Preference.OnPreferenceChangeListener, LifecycleObserver, OnPause, OnResume {
+
+ private static final String KEY_ADD_USER_WHEN_LOCKED = "add_users_when_locked";
+
+ private RestrictedSwitchPreference mAddUserWhenLocked;
+ private UserCapabilities mUserCaps;
+ private boolean mShouldUpdateUserList;
+
+ public AddUserWhenLockedPreferenceController(Context context) {
+ super(context);
+ mUserCaps = UserCapabilities.create(context);
+ }
+
+ @Override
+ public void updateState(Preference preference) {
+ RestrictedSwitchPreference restrictedSwitchPreference =
+ (RestrictedSwitchPreference) preference;
+ int value = Global.getInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 0);
+ restrictedSwitchPreference.setChecked(value == 1);
+ restrictedSwitchPreference.setDisabledByAdmin(
+ mUserCaps.disallowAddUser() ? mUserCaps.getEnforcedAdmin() : null);
+ }
+
+ @Override
+ public boolean onPreferenceChange(Preference preference, Object newValue) {
+ Boolean value = (Boolean) newValue;
+ Global.putInt(mContext.getContentResolver(),
+ Global.ADD_USERS_WHEN_LOCKED, value != null && value ? 1 : 0);
+ return true;
+ }
+
+ @Override
+ public void onPause() {
+ mShouldUpdateUserList = true;
+ }
+
+ @Override
+ public void onResume() {
+ if (mShouldUpdateUserList) {
+ mUserCaps.updateAddUserCapabilities(mContext);
+ }
+ }
+
+ @Override
+ public boolean handlePreferenceTreeClick(Preference preference) {
+ return false;
+ }
+
+ @Override
+ public boolean isAvailable() {
+ return mUserCaps.isAdmin() &&
+ (!mUserCaps.disallowAddUser() || mUserCaps.disallowAddUserSetByAdmin());
+ }
+
+ @Override
+ public String getPreferenceKey() {
+ return KEY_ADD_USER_WHEN_LOCKED;
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2016 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.accounts;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.core.PreferenceController;
+import com.android.settings.search.SearchIndexableRaw;
+
+import java.util.List;
+
+public class EmergencyInfoPreferenceController extends PreferenceController {
+
+ private static final String KEY_EMERGENCY_INFO = "emergency_info";
+ private static final String ACTION_EDIT_EMERGENCY_INFO = "android.settings.EDIT_EMERGENGY_INFO";
+ private static final String PACKAGE_NAME_EMERGENCY = "com.android.emergency";
+
+ public EmergencyInfoPreferenceController(Context context) {
+ super(context);
+ }
+
+ @Override
+ public void displayPreference(PreferenceScreen screen) {
+ super.displayPreference(screen);
+ }
+
+ @Override
+ public void updateRawDataToIndex(List<SearchIndexableRaw> rawData) {
+ if (isAvailable()) {
+ SearchIndexableRaw data = new SearchIndexableRaw(mContext);
+ final Resources res = mContext.getResources();
+ data.title = res.getString(com.android.settings.R.string.emergency_info_title);
+ data.screenTitle = res.getString(com.android.settings.R.string.emergency_info_title);
+ rawData.add(data);
+ }
+ }
+
+ @Override
+ public boolean handlePreferenceTreeClick(Preference preference) {
+ if (KEY_EMERGENCY_INFO.equals(preference.getKey())) {
+ Intent intent = new Intent(ACTION_EDIT_EMERGENCY_INFO);
+ intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ mContext.startActivity(intent);
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isAvailable() {
+ Intent intent = new Intent(ACTION_EDIT_EMERGENCY_INFO).setPackage(PACKAGE_NAME_EMERGENCY);
+ List<ResolveInfo> infos = mContext.getPackageManager().queryIntentActivities(intent, 0);
+ return infos != null && !infos.isEmpty();
+ }
+
+ @Override
+ public String getPreferenceKey() {
+ return KEY_EMERGENCY_INFO;
+ }
+}
import com.android.settings.dashboard.DashboardFragment;
import com.android.settingslib.drawer.CategoryKey;
+import java.util.ArrayList;
import java.util.List;
public class UserAndAccountDashboardFragment extends DashboardFragment {
@Override
protected int getPreferenceScreenResId() {
- return R.xml.account_settings;
+ return R.xml.user_and_accounts_settings;
}
@Override
protected List<PreferenceController> getPreferenceControllers(Context context) {
- return null;
+ final List<PreferenceController> controllers = new ArrayList<>();
+ controllers.add(new EmergencyInfoPreferenceController(context));
+ AddUserWhenLockedPreferenceController addUserWhenLockedPrefController =
+ new AddUserWhenLockedPreferenceController(context);
+ controllers.add(addUserWhenLockedPrefController);
+ getLifecycle().addObserver(addUserWhenLockedPrefController);
+ return controllers;
}
}
\ No newline at end of file
import android.content.Context;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
+import com.android.settings.search.SearchIndexableRaw;
import java.util.List;
}
/**
+ * Updates raw data for search provider.
+ *
+ * Called by SearchIndexProvider#getRawDataToIndex
+ */
+ public void updateRawDataToIndex(List<SearchIndexableRaw> rawData) {
+ }
+
+ /**
* Returns true if preference is available (should be displayed)
*/
public abstract boolean isAvailable();
--- /dev/null
+/*
+ * Copyright (C) 2016 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.users;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.pm.UserInfo;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.provider.Settings;
+import com.android.settings.Utils;
+import com.android.settingslib.RestrictedLockUtils;
+
+public class UserCapabilities {
+ boolean mEnabled = true;
+ boolean mCanAddUser = true;
+ boolean mCanAddRestrictedProfile = true;
+ boolean mIsAdmin;
+ boolean mIsGuest;
+ boolean mCanAddGuest;
+ boolean mDisallowAddUser;
+ boolean mDisallowAddUserSetByAdmin;
+ RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
+
+ private UserCapabilities() {}
+
+ public static UserCapabilities create(Context context) {
+ UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
+ UserCapabilities caps = new UserCapabilities();
+ if (!UserManager.supportsMultipleUsers() || Utils.isMonkeyRunning()) {
+ caps.mEnabled = false;
+ return caps;
+ }
+
+ final UserInfo myUserInfo = userManager.getUserInfo(UserHandle.myUserId());
+ caps.mIsGuest = myUserInfo.isGuest();
+ caps.mIsAdmin = myUserInfo.isAdmin();
+ DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
+ Context.DEVICE_POLICY_SERVICE);
+ // No restricted profiles for tablets with a device owner, or phones.
+ if (dpm.isDeviceManaged() || Utils.isVoiceCapable(context)) {
+ caps.mCanAddRestrictedProfile = false;
+ }
+ caps.updateAddUserCapabilities(context);
+ return caps;
+ }
+
+ public void updateAddUserCapabilities(Context context) {
+ mEnforcedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(context,
+ UserManager.DISALLOW_ADD_USER, UserHandle.myUserId());
+ final boolean hasBaseUserRestriction = RestrictedLockUtils.hasBaseUserRestriction(
+ context, UserManager.DISALLOW_ADD_USER, UserHandle.myUserId());
+ mDisallowAddUserSetByAdmin =
+ mEnforcedAdmin != null && !hasBaseUserRestriction;
+ mDisallowAddUser =
+ (mEnforcedAdmin != null || hasBaseUserRestriction);
+ mCanAddUser = true;
+ if (!mIsAdmin || UserManager.getMaxSupportedUsers() < 2
+ || !UserManager.supportsMultipleUsers()
+ || mDisallowAddUser) {
+ mCanAddUser = false;
+ }
+
+ final boolean canAddUsersWhenLocked = mIsAdmin || Settings.Global.getInt(
+ context.getContentResolver(), Settings.Global.ADD_USERS_WHEN_LOCKED, 0) == 1;
+ mCanAddGuest = !mIsGuest && !mDisallowAddUser && canAddUsersWhenLocked;
+ }
+
+ public boolean isAdmin() {
+ return mIsAdmin;
+ }
+
+ public boolean disallowAddUser() {
+ return mDisallowAddUser;
+ }
+
+ public boolean disallowAddUserSetByAdmin() {
+ return mDisallowAddUserSetByAdmin;
+ }
+
+ public RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin() {
+ return mEnforcedAdmin;
+ }
+
+
+ @Override
+ public String toString() {
+ return "UserCapabilities{" +
+ "mEnabled=" + mEnabled +
+ ", mCanAddUser=" + mCanAddUser +
+ ", mCanAddRestrictedProfile=" + mCanAddRestrictedProfile +
+ ", mIsAdmin=" + mIsAdmin +
+ ", mIsGuest=" + mIsGuest +
+ ", mCanAddGuest=" + mCanAddGuest +
+ ", mDisallowAddUser=" + mDisallowAddUser +
+ ", mEnforcedAdmin=" + mEnforcedAdmin +
+ '}';
+ }
+}
mMePreference.setTitle(label);
}
- private static class UserCapabilities {
- boolean mEnabled = true;
- boolean mCanAddUser = true;
- boolean mCanAddRestrictedProfile = true;
- boolean mIsAdmin;
- boolean mIsGuest;
- boolean mCanAddGuest;
- boolean mDisallowAddUser;
- boolean mDisallowAddUserSetByAdmin;
- EnforcedAdmin mEnforcedAdmin;
-
- private UserCapabilities() {}
-
- public static UserCapabilities create(Context context) {
- UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
- UserCapabilities caps = new UserCapabilities();
- if (!UserManager.supportsMultipleUsers() || Utils.isMonkeyRunning()) {
- caps.mEnabled = false;
- return caps;
- }
-
- final UserInfo myUserInfo = userManager.getUserInfo(UserHandle.myUserId());
- caps.mIsGuest = myUserInfo.isGuest();
- caps.mIsAdmin = myUserInfo.isAdmin();
- DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
- Context.DEVICE_POLICY_SERVICE);
- // No restricted profiles for tablets with a device owner, or phones.
- if (dpm.isDeviceManaged() || Utils.isVoiceCapable(context)) {
- caps.mCanAddRestrictedProfile = false;
- }
- caps.updateAddUserCapabilities(context);
- return caps;
- }
-
- public void updateAddUserCapabilities(Context context) {
- mEnforcedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(context,
- UserManager.DISALLOW_ADD_USER, UserHandle.myUserId());
- final boolean hasBaseUserRestriction = RestrictedLockUtils.hasBaseUserRestriction(
- context, UserManager.DISALLOW_ADD_USER, UserHandle.myUserId());
- mDisallowAddUserSetByAdmin =
- mEnforcedAdmin != null && !hasBaseUserRestriction;
- mDisallowAddUser =
- (mEnforcedAdmin != null || hasBaseUserRestriction);
- mCanAddUser = true;
- if (!mIsAdmin || UserManager.getMaxSupportedUsers() < 2
- || !UserManager.supportsMultipleUsers()
- || mDisallowAddUser) {
- mCanAddUser = false;
- }
-
- final boolean canAddUsersWhenLocked = mIsAdmin || Settings.Global.getInt(
- context.getContentResolver(), Settings.Global.ADD_USERS_WHEN_LOCKED, 0) == 1;
- mCanAddGuest = !mIsGuest && !mDisallowAddUser && canAddUsersWhenLocked;
- }
-
- @Override
- public String toString() {
- return "UserCapabilities{" +
- "mEnabled=" + mEnabled +
- ", mCanAddUser=" + mCanAddUser +
- ", mCanAddRestrictedProfile=" + mCanAddRestrictedProfile +
- ", mIsAdmin=" + mIsAdmin +
- ", mIsGuest=" + mIsGuest +
- ", mCanAddGuest=" + mCanAddGuest +
- ", mDisallowAddUser=" + mDisallowAddUser +
- ", mEnforcedAdmin=" + mEnforcedAdmin +
- '}';
- }
- }
-
private static class SummaryProvider implements SummaryLoader.SummaryProvider {
private final Context mContext;
--- /dev/null
+/*
+ * Copyright (C) 2016 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.accounts;
+
+import android.content.Context;
+import android.content.pm.UserInfo;
+import android.os.UserManager;
+import android.provider.Settings.Global;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+import com.android.settingslib.RestrictedSwitchPreference;
+
+import com.android.settings.SettingsRobolectricTestRunner;
+import com.android.settings.TestConfig;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class AddUserWhenLockedPreferenceControllerTest {
+
+ @Mock(answer = RETURNS_DEEP_STUBS)
+ private PreferenceScreen mScreen;
+ @Mock(answer = RETURNS_DEEP_STUBS)
+ private UserInfo mUserInfo;
+ @Mock(answer = RETURNS_DEEP_STUBS)
+ private UserManager mUserManager;
+
+ private Context mContext;
+ private AddUserWhenLockedPreferenceController mController;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ ShadowApplication shadowContext = ShadowApplication.getInstance();
+ shadowContext.setSystemService(Context.USER_SERVICE, mUserManager);
+ mContext = shadowContext.getApplicationContext();
+ mController = new AddUserWhenLockedPreferenceController(mContext);
+ }
+
+ @Test
+ public void displayPref_NotAdmin_shouldNotDisplay() {
+ when(mUserManager.getUserInfo(anyInt())).thenReturn(mUserInfo);
+ when(mUserInfo.isAdmin()).thenReturn(false);
+
+ mController.displayPreference(mScreen);
+
+ verify(mScreen).removePreference(any(Preference.class));
+ }
+
+ @Test
+ public void updateState_preferenceSetCheckedWhenSettingIsOn() {
+ final RestrictedSwitchPreference preference = mock(RestrictedSwitchPreference.class);
+ Global.putInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 1);
+
+ mController.updateState(preference);
+
+ verify(preference).setChecked(true);
+ }
+
+ @Test
+ public void updateState_preferenceSetUncheckedWhenSettingIsOff() {
+ final RestrictedSwitchPreference preference = mock(RestrictedSwitchPreference.class);
+ Global.putInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 0);
+
+ mController.updateState(preference);
+
+ verify(preference).setChecked(false);
+ }
+
+ @Test
+ public void onPreferenceChange_SettingIsOnWhenPreferenceChecked() {
+ final RestrictedSwitchPreference preference = mock(RestrictedSwitchPreference.class);
+ preference.setChecked(true);
+
+ mController.onPreferenceChange(preference, Boolean.TRUE);
+
+ assertThat(Global.getInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 0))
+ .isEqualTo(1);
+ }
+
+ @Test
+ public void onPreferenceChange_SettingIsOffWhenPreferenceNotChecked() {
+ final RestrictedSwitchPreference preference = mock(RestrictedSwitchPreference.class);
+ preference.setChecked(false);
+
+ mController.onPreferenceChange(preference, Boolean.FALSE);
+
+ assertThat(Global.getInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 0))
+ .isEqualTo(0);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2016 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.accounts;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+import com.android.settings.SettingsRobolectricTestRunner;
+import com.android.settings.TestConfig;
+import com.android.settings.search.SearchIndexableRaw;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class EmergencyInfoPreferenceControllerTest {
+
+ @Mock(answer = RETURNS_DEEP_STUBS)
+ private Context mContext;
+ @Mock(answer = RETURNS_DEEP_STUBS)
+ private PreferenceScreen mScreen;
+
+ private EmergencyInfoPreferenceController mController;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ mController = new EmergencyInfoPreferenceController(mContext);
+ }
+
+ @Test
+ public void updateRawDataToIndex_prefUnavaiable_shouldNotUpdate() {
+ final List<SearchIndexableRaw> data = new ArrayList<>();
+ when(mContext.getPackageManager().queryIntentActivities(
+ any(Intent.class), anyInt()))
+ .thenReturn(null);
+
+ mController.updateRawDataToIndex(data);
+
+ assertThat(data).isEmpty();
+ }
+
+ @Test
+ public void updateRawDataToIndex_prefAvaiable_shouldUpdate() {
+ final List<SearchIndexableRaw> data = new ArrayList<>();
+ final List<ResolveInfo> infos = new ArrayList<>();
+ infos.add(new ResolveInfo());
+ when(mContext.getPackageManager().queryIntentActivities(
+ any(Intent.class), anyInt()))
+ .thenReturn(infos);
+
+ mController.updateRawDataToIndex(data);
+
+ assertThat(data).isNotEmpty();
+ }
+
+ @Test
+ public void displayPref_prefUnAvaiable_shouldNotDisplay() {
+ when(mContext.getPackageManager().queryIntentActivities(
+ any(Intent.class), anyInt()))
+ .thenReturn(null);
+
+ mController.displayPreference(mScreen);
+
+ verify(mScreen).removePreference(any(Preference.class));
+ }
+
+ @Test
+ public void displayPref_prefAvaiable_shouldDisplay() {
+ final List<SearchIndexableRaw> data = new ArrayList<>();
+ final List<ResolveInfo> infos = new ArrayList<>();
+ infos.add(new ResolveInfo());
+ when(mContext.getPackageManager().queryIntentActivities(
+ any(Intent.class), anyInt()))
+ .thenReturn(infos);
+
+ mController.displayPreference(mScreen);
+
+ verify(mScreen, never()).removePreference(any(Preference.class));
+ }
+
+ @Test
+ public void handlePreferenceTreeClick_shouldStartActivity() {
+ final Preference preference = mock(Preference.class);
+ final ShadowApplication application = ShadowApplication.getInstance();
+ final Context context = application.getApplicationContext();
+ mController = new EmergencyInfoPreferenceController(context);
+
+ mController.handlePreferenceTreeClick(preference);
+
+ assertThat(application.getNextStartedActivity().getAction())
+ .isEqualTo("android.settings.EDIT_EMERGENGY_INFO");
+ }
+}
OSDN Git Service
