@Override @SuppressWarnings("ResourceType") protected void setUp() throws Exception { super.setUp(); preferences = mock(SharedPreferences.class); when(preferences.getBoolean(eq(KEY_PREF_SERVICE_ENABLED), anyBoolean())).thenReturn(true); when(preferences.getBoolean(eq(KEY_PREF_SERVICE_ENABLED), anyBoolean())).thenReturn(true); when(preferences.getString(eq(KEY_PREF_SENDER_ACCOUNT), anyString())) .thenReturn("*****@*****.**"); when(preferences.getString(eq(KEY_PREF_SENDER_PASSWORD), anyString())).thenReturn("password"); when(preferences.getString(eq(KEY_PREF_RECIPIENTS_ADDRESS), anyString())) .thenReturn("*****@*****.**"); when(preferences.getString(eq(KEY_PREF_EMAIL_HOST), anyString())).thenReturn("smtp.mail.com"); when(preferences.getString(eq(KEY_PREF_EMAIL_PORT), anyString())).thenReturn("111"); when(preferences.getStringSet(eq(KEY_PREF_EMAIL_TRIGGERS), anySetOf(String.class))) .thenReturn(DEFAULT_TRIGGERS); when(preferences.getStringSet(eq(KEY_PREF_EMAIL_CONTENT), anySetOf(String.class))) .thenReturn(DEFAULT_CONTENT); networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); context = mock(Context.class); when(context.getSystemService(eq(Context.CONNECTIVITY_SERVICE))) .thenReturn(connectivityManager); when(context.getContentResolver()).thenReturn(getContext().getContentResolver()); when(context.getResources()).thenReturn(getContext().getResources()); when(context.getSharedPreferences(anyString(), anyInt())).thenReturn(preferences); database = new Database(getContext(), "test.sqlite"); /* not mock context */ database.destroy(); cryptor = mock(Cryptor.class); when(cryptor.decrypt(anyString())) .then( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return "decrypted " + invocation.getArguments()[0]; } }); transport = mock(MailTransport.class); notifications = mock(Notifications.class); }
public void restorePreferences() { // Restore last tab SharedPreferences settings = getPreferences(MODE_PRIVATE); curTab = settings.getInt("lastTab", 0); // Restore last expanded buildings (by tab) nearbyExpandedBldgs = settings.getStringSet("lastNearbyExpandedBuildings", new HashSet<String>()); allExpandedBldgs = settings.getStringSet("lastAllExpandedBuildings", new HashSet<String>()); // Restore position in each tab sm.setCurPos(settings.getInt("curPosIndex", 0), settings.getInt("curPosTop", 0)); sm.setNearbyPos(settings.getInt("nearPosIndex", 0), settings.getInt("nearPosTop", 0)); sm.setAllPos(settings.getInt("allPosIndex", 0), settings.getInt("allPosTop", 0)); }
private void startSearch() { if (searchRunning != 0) { Toast.makeText(getActivity(), "Suche läuft bereits.", Toast.LENGTH_SHORT).show(); return; } getActivity().setProgressBarIndeterminateVisibility(true); searchString = ((TextView) rootView.findViewById(R.id.autoCompleteTextView1)).getText().toString(); String url = "http://" + conf.getString("HOST", "") + ":" + String.valueOf(conf.getString("PORT", "80")); Bundle args = new Bundle(); args.putString("url", url); if (vollSuche) { for (String rai : conf.getStringSet("rai_list", new HashSet<String>())) { searchRunning++; adapter.changeCursor(null); args.putString("search", rai); getLoaderManager().restartLoader(Katalog.LOCATION, args, this); } } else { args.putString("search", searchString); // new FetchLocation(getActivity(), new FetchLocationListener()).execute(args); searchRunning++; // 1. Hier geht's los!! getLoaderManager().restartLoader(Katalog.LOCATION, args, this); } }
public static void removeFromInstallQueue( Context context, ArrayList<String> packageNames, UserHandleCompat user) { if (packageNames.isEmpty()) { return; } String spKey = LauncherAppState.getSharedPreferencesKey(); SharedPreferences sp = context.getSharedPreferences(spKey, Context.MODE_PRIVATE); synchronized (sLock) { Set<String> strings = sp.getStringSet(APPS_PENDING_INSTALL, null); if (DBG) { Log.d(TAG, "APPS_PENDING_INSTALL: " + strings + ", removing packages: " + packageNames); } if (strings != null) { Set<String> newStrings = new HashSet<String>(strings); Iterator<String> newStringsIter = newStrings.iterator(); while (newStringsIter.hasNext()) { String encoded = newStringsIter.next(); PendingInstallShortcutInfo info = decode(encoded, context); if (info == null || (packageNames.contains(info.getTargetPackage()) && user.equals(info.user))) { newStringsIter.remove(); } } sp.edit().putStringSet(APPS_PENDING_INSTALL, newStrings).commit(); } } }
@SuppressWarnings("unchecked") public void onClick_blockHost(View view) { Set<String> defaultSet = new HashSet<>(); SharedPreferences blocked_hosts = Dynamo_Interface.application_context.getSharedPreferences( "blocked_hosts", Context.MODE_PRIVATE); ArrayList<String> host_list = new ArrayList<>(blocked_hosts.getStringSet("hosts", defaultSet)); if (!host_list.contains(viewing_post.getHost())) { host_list.add(viewing_post.getHost()); Set updated_List = new HashSet(host_list); SharedPreferences.Editor editor = blocked_hosts.edit(); editor.putStringSet("hosts", updated_List); editor.commit(); new AlertDialog.Builder(view_post_screen.this) .setTitle("Host Block") .setMessage( viewing_post.getHost() + " is now blocked. Check the ban list screen to undo this action") .setPositiveButton( "OK", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { startActivity(new Intent(view_post_screen.this, view_post_list_screen.class)); } }) .show(); } else { new AlertDialog.Builder(view_post_screen.this) .setTitle("Already Blocked") .setMessage("That host has already been blocked.") .setPositiveButton("OK", null) .show(); } }
/** * Returns the set of long codes of the keys assigned to a preference. * * @param context The context to use for a PreferenceManager * @param key The preference key * @return The {@code Set<Long>} of the keys assigned to the preference */ public static Set<Long> getKeyCodesForPreference(Context context, String key) { final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); Set<Long> result = new HashSet<>(); try { Set<String> longPrefStringSet = prefs.getStringSet(key, Collections.EMPTY_SET); for (String longPrefString : longPrefStringSet) { result.add(Long.valueOf(longPrefString)); } } catch (ClassCastException e) { /* * Key maps to preference that is not a set. Fall back on legacy behavior before we * supported multiple keys */ long keyCode = prefs.getLong(key, KeyComboPreference.INVALID_EXTENDED_KEY_CODE); if (keyCode != INVALID_EXTENDED_KEY_CODE) { result.add(keyCode); } } catch (NumberFormatException e) { /* * One of the strings in the string set can't be converted to a Long. This should * not be possible unless the preferences are corrupted. Remove the preference and * return an empty set. */ prefs.edit().remove(key).apply(); } return result; }
private void reloadSoundsToPlayList() { HashSet<String> defaultSounds = new HashSet<String>(); defaultSounds.add("sound_start"); defaultSounds.add("sound_error"); defaultSounds.add("sound_end"); mSoundsToPlayList = prefs.getStringSet(Common.PREF_SOUNDS_TO_PLAY, defaultSounds); }
@Nullable @Override public Set<String> getStringSet(String key, Set<String> defValues) { SharedPreferences sp = context.getSharedPreferences(SharedPreferencesName, Context.MODE_PRIVATE); return sp.getStringSet(key, defValues); }
public void deleteFromSharedPref(SharedPreferences prefs) { SharedPreferences.Editor editor = prefs.edit(); String key = PREF_TIMER_ID + Integer.toString(mTimerId); String id = Integer.toString(mTimerId); editor.remove(key); key = PREF_START_TIME + id; editor.remove(key); key = PREF_TIME_LEFT + id; editor.remove(key); key = PREF_ORIGINAL_TIME + id; editor.remove(key); key = PREF_SETUP_TIME + id; editor.remove(key); key = PREF_STATE + id; editor.remove(key); Set<String> timersList = prefs.getStringSet(PREF_TIMERS_LIST, new HashSet<String>()); timersList.remove(id); editor.putStringSet(PREF_TIMERS_LIST, timersList); key = PREF_LABEL + id; editor.remove(key); key = PREF_DELETE_AFTER_USE + id; editor.remove(key); editor.commit(); // dumpTimersFromSharedPrefs(prefs); }
public static boolean existInFavorites(Context context, MovieEntity entity) { SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context); Set<String> movieFavoritesList = sp.getStringSet(ConstantValues.PREF_MOVIE_FAVORITES, null); if (movieFavoritesList != null && movieFavoritesList.contains(String.valueOf(entity.getId()))) return true; return false; }
@SuppressLint("NewApi") @Override public Set<String> getStringSet(String key, Set<String> defValue) { if (VERSION.SDK_INT >= 11) { return prefs.getStringSet(key, defValue); } else { return getSet(key, defValue, String.class); } }
public void saveLeaguer(String spName, String key, String leaguer) { SharedPreferences sp = getApplicationContext().getSharedPreferences(spName, MODE_PRIVATE); Set<String> teamLeaguer = sp.getStringSet(key, new LinkedHashSet<String>()); Editor edit = sp.edit(); teamLeaguer.add(leaguer); edit.putStringSet(key, teamLeaguer); edit.commit(); }
public boolean isFavorite(Context context) { SharedPreferences settings = context.getSharedPreferences("CSPPrefsFile", 0); List<String> favs = new ArrayList<String>(settings.getStringSet("Favorites", null)); if (favs == null) { return false; } return favs.contains(String.valueOf(this.unitID)); }
public static void removeFromFavorites(Context context, MovieEntity entity) { SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context); Set<String> movieFavoritesList = sp.getStringSet(ConstantValues.PREF_MOVIE_FAVORITES, null); if (movieFavoritesList == null) movieFavoritesList = new TreeSet<String>(); movieFavoritesList.remove(String.valueOf(entity.getId())); sp.edit().putStringSet(ConstantValues.PREF_MOVIE_FAVORITES, movieFavoritesList).apply(); }
public boolean getFollowers(Twitter twitter) { boolean newActivity = false; try { List<User> followers = twitter.getFollowersList( useSecondAccount ? AppSettings.getInstance(context).secondScreenName : AppSettings.getInstance(context).myScreenName, -1, 200); User me = twitter.verifyCredentials(); int oldFollowerCount = sharedPrefs.getInt("activity_follower_count_" + currentAccount, 0); Set<String> latestFollowers = sharedPrefs.getStringSet( "activity_latest_followers_" + currentAccount, new HashSet<String>()); Log.v(TAG, "followers set size: " + latestFollowers.size()); Log.v(TAG, "old follower count: " + oldFollowerCount); Log.v(TAG, "current follower count: " + me.getFollowersCount()); List<User> newFollowers = new ArrayList<User>(); if (latestFollowers.size() != 0) { for (int i = 0; i < followers.size(); i++) { if (!latestFollowers.contains(followers.get(i).getScreenName())) { Log.v(TAG, "inserting @" + followers.get(i).getScreenName() + " as new follower"); newFollowers.add(followers.get(i)); newActivity = true; } else { break; } } } insertFollowers(newFollowers); latestFollowers.clear(); for (int i = 0; i < 50; i++) { if (i < followers.size()) { latestFollowers.add(followers.get(i).getScreenName()); } else { break; } } SharedPreferences.Editor e = sharedPrefs.edit(); e.putStringSet("activity_latest_followers_" + currentAccount, latestFollowers); e.putInt("activity_follower_count_" + currentAccount, me.getFollowersCount()); e.commit(); } catch (TwitterException e) { e.printStackTrace(); } return newActivity; }
private ArrayList<String> getArray() { SharedPreferences sp = this.getSharedPreferences(SHARED_PREFS_NAME, Activity.MODE_PRIVATE); // NOTE: if shared preference is null, the method return empty Hashset and not null Set<String> set = sp.getStringSet("list", new LinkedHashSet<String>()); // Toast.makeText(this, "print linkedhashset " + set.toString(), Toast.LENGTH_LONG).show(); return new ArrayList<String>(set); }
public ListPreferenceCustom(Context context, AttributeSet attrs, int array, String stringSetKey) { super(context, attrs); String defaultItemsArray[] = context.getResources().getStringArray(array); SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context); Set<String> itemsSet = sharedPreferences.getStringSet(stringSetKey, Globals.arrayToSet(defaultItemsArray)); String items[] = Globals.setToArray(itemsSet); this.setEntries(items); this.setEntryValues(items); }
public static void dumpTimersFromSharedPrefs(SharedPreferences prefs) { Object[] timerStrings = prefs.getStringSet(PREF_TIMERS_LIST, new HashSet<String>()).toArray(); Log.v(TAG, "--------------------- timers list in shared prefs"); if (timerStrings.length > 0) { for (int i = 0; i < timerStrings.length; i++) { int id = Integer.parseInt((String) timerStrings[i]); Log.v(TAG, "---------------------timer " + (i + 1) + ": id - " + id); } } }
protected String[] getCalendarIds() { Set<String> calendarPreference = sharedPref.getStringSet( SettingsFragment.PREFERENCE_KEY_RELEVANT_CALENDARS, new HashSet<String>(0)); if (calendarPreference == null) { return new String[0]; } else { return calendarPreference.toArray(new String[calendarPreference.size()]); } }
/** Initiate ViewPager and PagerAdapter */ public void initPager() { // Initiate PagerAdapter PagerAdapter mPagerAdapter = new PagerAdapter(getFragmentManager()); Bundle bundle = new Bundle(); bundle.putString(MIME_TYPE, Audio.Playlists.CONTENT_TYPE); bundle.putLong(BaseColumns._ID, PLAYLIST_RECENTLY_ADDED); // Get tab visibility preferences SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); Set<String> defaults = new HashSet<String>(Arrays.asList(getResources().getStringArray(R.array.tab_titles))); Set<String> tabs_set = sp.getStringSet(TABS_ENABLED, defaults); // if its empty fill reset it to full defaults // stops app from crashing when no tabs are shown // TODO:rewrite activity to not crash when no tabs are chosen to show if (tabs_set.size() == 0) { tabs_set = defaults; } // Only show tabs that were set in preferences // Recently added tracks if (tabs_set.contains(getResources().getString(R.string.tab_recent))) mPagerAdapter.addFragment(new RecentlyAddedFragment(bundle)); // Artists if (tabs_set.contains(getResources().getString(R.string.tab_artists))) mPagerAdapter.addFragment(new ArtistsFragment()); // Albums if (tabs_set.contains(getResources().getString(R.string.tab_albums))) mPagerAdapter.addFragment(new AlbumsFragment()); // // Tracks if (tabs_set.contains(getResources().getString(R.string.tab_songs))) mPagerAdapter.addFragment(new TracksFragment()); // // Playlists if (tabs_set.contains(getResources().getString(R.string.tab_playlists))) mPagerAdapter.addFragment(new PlaylistsFragment()); // // Genres if (tabs_set.contains(getResources().getString(R.string.tab_genres))) mPagerAdapter.addFragment(new GenresFragment()); // Initiate ViewPager ViewPager mViewPager = (ViewPager) findViewById(R.id.viewPager); mViewPager.setPageMargin(getResources().getInteger(R.integer.viewpager_margin_width)); mViewPager.setPageMarginDrawable(R.drawable.viewpager_margin); mViewPager.setOffscreenPageLimit(mPagerAdapter.getCount()); mViewPager.setAdapter(mPagerAdapter); // mViewPager.setCurrentItem(0); // Tabs initScrollableTabs(mViewPager); // Theme chooser ThemeUtils.initThemeChooser(this, mViewPager, "viewpager", THEME_ITEM_BACKGROUND); ThemeUtils.setMarginDrawable(this, mViewPager, "viewpager_margin"); }
/** * If the LocalWorkspace has saved preferences, this method loads them. * * <p>Returns true if preferences exist, false otherwise */ protected boolean loadPreferences() { SharedPreferences settings = GlobalContext.getGC().getPreferences(0); // Settigns exist for this LocalWorkspace if (settings.getBoolean(genPrefKey(LocalWorkspace.HAS_PREFS_KEY), false)) { setVisibility(settings.getBoolean(genPrefKey(LocalWorkspace.IS_PUBLIC_KEY), isPublic())); int storedMaxSize = settings.getInt(genPrefKey(LocalWorkspace.SIZE_KEY), getMaxSpace()); if (storedMaxSize < getUsedSpace()) { try { setMaxSpace(getUsedSpace()); Log.w( Constants.LOG_TAG, String.format( "LocalWorkspace.loadPreferences, name: %s, " + "Invalid stored MaxSize: %d. \n" + "Files must have been altered externally. New maxSize : %d.", getName(), storedMaxSize, getUsedSpace())); } catch (InvalidMaxSpace e) { Log.e( Constants.LOG_TAG, "LocalWorkspace.loadPreferences, setMaxSpace(getMaxSpace()); throwed InvalidMaxSpace"); System.exit(-1); } } tags = new ArrayList<>(settings.getStringSet(genPrefKey(LocalWorkspace.TAGS_KEY), null)); userACL = new ArrayList<>(settings.getStringSet(genPrefKey(LocalWorkspace.USERACL_KEY), null)); Log.i( Constants.LOG_TAG, String.format("LocalWorkspace.loadPreferences, name: %s, sucess", getName())); return true; } Log.i( Constants.LOG_TAG, String.format("LocalWorkspace.loadPreferences, name: %s, failure", getName())); return false; }
/** TODO: Move this code to RebootManager */ public void saveToPreferences(Context context) { SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context); SharedPreferences.Editor editor = sharedPreferences.edit(); Set<String> idSet = sharedPreferences.getStringSet(REBOOT_IDS, new HashSet<String>()); idSet.add(Integer.toString(mId)); editor.putStringSet(REBOOT_IDS, idSet); editor.putInt(Integer.toString(mId) + REBOOT_TIME_HOUR, mRebootHour); editor.putInt(Integer.toString(mId) + REBOOT_TIME_MINUTE, mRebootMinute); editor.putBoolean(Integer.toString(mId) + REBOOT_ACTIVE, isActive); editor.commit(); }
public void delete(Context context) { SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context); SharedPreferences.Editor editor = sharedPreferences.edit(); Set<String> idSet = sharedPreferences.getStringSet(REBOOT_IDS, new HashSet<String>()); idSet.remove(Integer.toString(mId)); editor.putStringSet(REBOOT_IDS, idSet); editor.remove(Integer.toString(mId) + REBOOT_TIME_HOUR); editor.remove(Integer.toString(mId) + REBOOT_TIME_MINUTE); editor.remove(Integer.toString(mId) + REBOOT_ACTIVE); editor.commit(); }
private void loadAvailableStylesPref() { if (currentSlobUri == null) { Log.w(TAG, "Can't load article view available styles pref - slob uri is null"); return; } SharedPreferences prefs = prefs(); Log.d(TAG, "Available styles before pref load: " + styleTitles.size()); styleTitles = new TreeSet( prefs.getStringSet(PREF_STYLE_AVAILABLE + currentSlobUri, Collections.EMPTY_SET)); Log.d(TAG, "Loaded available styles: " + styleTitles.size()); }
public static void getTimersFromSharedPrefs( SharedPreferences prefs, ArrayList<TimerObj> timers, int match) { Object[] timerStrings = prefs.getStringSet(PREF_TIMERS_LIST, new HashSet<String>()).toArray(); if (timerStrings.length > 0) { for (int i = 0; i < timerStrings.length; i++) { TimerObj t = new TimerObj(); t.mTimerId = Integer.parseInt((String) timerStrings[i]); t.readFromSharedPref(prefs); if (t.mState == match) { timers.add(t); } } } }
/** Listens for a change in the preferences */ @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { System.out.println("GUEEEEE ON SHARED PREFERENCE CHANGED"); if (key.equals(KEY_PREF_SYNC_CONN)) { System.out.println("key multilist changed"); MultiSelectListPreference connectionPref = (MultiSelectListPreference) findPreference(key); // Get the new values Set<String> set = sharedPreferences.getStringSet(key, null); // Set the new values on the list MainActivity.websNames = set.toArray(new String[0]); // Set the values on the list shown connectionPref.setValues(set); } }
private static void clearAllSnoozePreferences( final Context context, final SharedPreferences prefs) { NotificationManager nm = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); final Set<String> snoozedIds = prefs.getStringSet(PREF_SNOOZE_IDS, new HashSet<String>()); final SharedPreferences.Editor ed = prefs.edit(); for (String snoozeId : snoozedIds) { nm.cancel(Integer.parseInt(snoozeId)); ed.remove(getAlarmPrefSnoozeTimeKey(snoozeId)); } ed.remove(PREF_SNOOZE_IDS); ed.apply(); }
@Override public void onSharedPreferenceChanged( final SharedPreferences sharedPreferences, final String key) { if (key.equals("pref_force_desktop")) { mDesktopMode = sharedPreferences.getBoolean("pref_force_desktop", false); mNavigationHelper.onPrefChanged(); } else if (key.equals("pref_user_location_mode")) { final int mode = Integer.parseInt(mSharedPrefs.getString("pref_user_location_mode", "0")); if (mUserLocation.setLocationMode(mode)) mReloadNeeded = true; return; } else if (key.equals("pref_persistent_zoom")) { mPersistentZoom = mSharedPrefs.getBoolean("pref_persistent_zoom", false); return; } else if (key.equals("pref_fullscreen")) { mIitcWebView.updateFullscreenStatus(); mNavigationHelper.onPrefChanged(); return; } else if (key.equals("pref_android_menu")) { final String[] menuDefaults = getResources().getStringArray(R.array.pref_android_menu_default); mAdvancedMenu = mSharedPrefs.getStringSet( "pref_android_menu", new HashSet<String>(Arrays.asList(menuDefaults))); mNavigationHelper.setDebugMode(mAdvancedMenu.contains(R.string.menu_debug)); invalidateOptionsMenu(); // no reload needed return; } else if (key.equals("pref_fake_user_agent")) { mIitcWebView.setUserAgent(); } else if (key.equals("pref_last_plugin_update")) { final Long forceUpdate = sharedPreferences.getLong("pref_last_plugin_update", 0); if (forceUpdate == 0) mFileManager.updatePlugins(true); return; } else if (key.equals("pref_update_plugins_interval")) { final int interval = Integer.parseInt(mSharedPrefs.getString("pref_update_plugins_interval", "7")); mFileManager.setUpdateInterval(interval); return; } else if (key.equals("pref_press_twice_to_exit") || key.equals("pref_share_selected_tab") || key.equals("pref_messages") || key.equals("pref_secure_updates") || key.equals("pref_external_storage")) { // no reload needed return; } mReloadNeeded = true; }
public static ArrayList<TodoElement> getAllItems(final Context context) { final SharedPreferences preferences = context.getSharedPreferences(PREFS_NAME, 0); final Set<String> ids = preferences.getStringSet(ITEMS_KEY, new HashSet<String>()); final ArrayList<TodoElement> items = new ArrayList<TodoElement>(); final HashSet<String> confirmedIds = new HashSet<String>(); for (final String id : ids) { final TodoElement item = getItem(context, UUID.fromString(id)); if (item != null) { items.add(item); confirmedIds.add(id); } } preferences.edit().putStringSet(ITEMS_KEY, confirmedIds).commit(); return items; }
public boolean isBlackListed() { String txt = mText; Set<String> blacklist = mSharedPref.getStringSet(_(R.string.pref_blacklist), null); if (blacklist != null) { for (String entry : blacklist) { entry = entry.replace(".", "\\.").replace("*", ".*"); Pattern pat = Pattern.compile(entry, Pattern.DOTALL); if (pat.matcher(txt).matches()) { Log.d(TAG, txt + " matches " + entry); return true; } } } Set<String> appblacklist = mSharedPref.getStringSet(_(R.string.pref_blocked_applist), null); if (appblacklist != null) { for (String entry : appblacklist) { if (entry.equals(mPkg)) { return true; } } } return false; }