diff --git a/res/values/strings.xml b/res/values/strings.xml index 14b78999fd7..967b74eb374 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -7932,4 +7932,11 @@ Your storage is now being managed by the storage manager + + + Accounts + + + Configure + diff --git a/res/xml/user_and_accounts_settings.xml b/res/xml/user_and_accounts_settings.xml new file mode 100644 index 00000000000..fb09bb6ab9c --- /dev/null +++ b/res/xml/user_and_accounts_settings.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/accounts/AddUserWhenLockedPreferenceController.java b/src/com/android/settings/accounts/AddUserWhenLockedPreferenceController.java new file mode 100644 index 00000000000..898d4a272d9 --- /dev/null +++ b/src/com/android/settings/accounts/AddUserWhenLockedPreferenceController.java @@ -0,0 +1,88 @@ +/* + * 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; + } +} diff --git a/src/com/android/settings/accounts/EmergencyInfoPreferenceController.java b/src/com/android/settings/accounts/EmergencyInfoPreferenceController.java new file mode 100644 index 00000000000..6f0dfae3c06 --- /dev/null +++ b/src/com/android/settings/accounts/EmergencyInfoPreferenceController.java @@ -0,0 +1,78 @@ +/* + * 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 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 infos = mContext.getPackageManager().queryIntentActivities(intent, 0); + return infos != null && !infos.isEmpty(); + } + + @Override + public String getPreferenceKey() { + return KEY_EMERGENCY_INFO; + } +} diff --git a/src/com/android/settings/accounts/UserAndAccountDashboardFragment.java b/src/com/android/settings/accounts/UserAndAccountDashboardFragment.java index 34d6dc44b77..bb4d8a106f3 100644 --- a/src/com/android/settings/accounts/UserAndAccountDashboardFragment.java +++ b/src/com/android/settings/accounts/UserAndAccountDashboardFragment.java @@ -23,6 +23,7 @@ import com.android.settings.core.PreferenceController; 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 { @@ -46,12 +47,18 @@ public class UserAndAccountDashboardFragment extends DashboardFragment { @Override protected int getPreferenceScreenResId() { - return R.xml.account_settings; + return R.xml.user_and_accounts_settings; } @Override protected List getPreferenceControllers(Context context) { - return null; + final List 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 diff --git a/src/com/android/settings/core/PreferenceController.java b/src/com/android/settings/core/PreferenceController.java index 50e9b2c15f7..93ffe36aab3 100644 --- a/src/com/android/settings/core/PreferenceController.java +++ b/src/com/android/settings/core/PreferenceController.java @@ -18,6 +18,7 @@ package com.android.settings.core; 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; @@ -65,6 +66,14 @@ public abstract class PreferenceController { } } + /** + * Updates raw data for search provider. + * + * Called by SearchIndexProvider#getRawDataToIndex + */ + public void updateRawDataToIndex(List rawData) { + } + /** * Returns true if preference is available (should be displayed) */ diff --git a/src/com/android/settings/users/UserCapabilities.java b/src/com/android/settings/users/UserCapabilities.java new file mode 100644 index 00000000000..a92e3e219e4 --- /dev/null +++ b/src/com/android/settings/users/UserCapabilities.java @@ -0,0 +1,113 @@ +/* + * 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 + + '}'; + } +} diff --git a/src/com/android/settings/users/UserSettings.java b/src/com/android/settings/users/UserSettings.java index ca455b8d8b6..fa2cdd4faea 100644 --- a/src/com/android/settings/users/UserSettings.java +++ b/src/com/android/settings/users/UserSettings.java @@ -1058,76 +1058,6 @@ public class UserSettings extends SettingsPreferenceFragment 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; diff --git a/tests/robotests/src/com/android/settings/accounts/AddUserWhenLockedPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accounts/AddUserWhenLockedPreferenceControllerTest.java new file mode 100644 index 00000000000..f49bb5fb472 --- /dev/null +++ b/tests/robotests/src/com/android/settings/accounts/AddUserWhenLockedPreferenceControllerTest.java @@ -0,0 +1,120 @@ +/* + * 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); + } + +} diff --git a/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java new file mode 100644 index 00000000000..b2ff344fd33 --- /dev/null +++ b/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java @@ -0,0 +1,126 @@ +/* + * 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 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 data = new ArrayList<>(); + final List 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 data = new ArrayList<>(); + final List 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"); + } +}