@Override
public void onReceive(final Context context, Intent intent) {
    Log.i(TAG, "Received " + intent);
    Util.logExtras(intent);

    String action = (intent == null ? null : intent.getAction());
    if (Intent.ACTION_BOOT_COMPLETED.equals(action) || Intent.ACTION_MY_PACKAGE_REPLACED.equals(action))
        try {
            // Upgrade settings
            upgrade(true, context);

            // Start service
            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
            if (prefs.getBoolean("enabled", false))
                ServiceSinkhole.start("receiver", context);
            else if (prefs.getBoolean("show_stats", false))
                ServiceSinkhole.run("receiver", context);

            if (Util.isInteractive(context))
                ServiceSinkhole.reloadStats("receiver", context);
        } catch (Throwable ex) {
            Log.e(TAG, ex.toString() + "\n" + Log.getStackTraceString(ex));
        }
}
 

@TargetApi(Build.VERSION_CODES.M)
private boolean checkPermissions(String name) {
    PreferenceScreen screen = getPreferenceScreen();
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

    // Check if permission was revoked
    if ((name == null || "disable_on_call".equals(name)) && prefs.getBoolean("disable_on_call", false))
        if (!Util.hasPhoneStatePermission(this)) {
            prefs.edit().putBoolean("disable_on_call", false).apply();
            ((TwoStatePreference) screen.findPreference("disable_on_call")).setChecked(false);

            requestPermissions(new String[]{Manifest.permission.READ_PHONE_STATE}, REQUEST_CALL);

            if (name != null)
                return false;
        }

    return true;
}
 

@Override
public void onStartSleepTimer(final long durationMS, final boolean stopAfterCurrent) {
    try {
        // save used duration to initialize the duration picker next time with this value
        SharedPreferences.Editor sharedPrefEditor = PreferenceManager.getDefaultSharedPreferences(this).edit();
        sharedPrefEditor.putLong(getString(R.string.pref_last_used_sleep_timer_key), durationMS);
        sharedPrefEditor.putBoolean(getString(R.string.pref_last_used_sleep_timer_stop_after_current_key), stopAfterCurrent);
        sharedPrefEditor.apply();

        getPlaybackService().startSleepTimer(durationMS, stopAfterCurrent);

        // show a snackbar to inform the user that the sleep timer is now set
        View layout = findViewById(R.id.drawer_layout);
        if (layout != null) {
            Snackbar sb = Snackbar.make(layout, R.string.snackbar_sleep_timer_confirmation_message, Snackbar.LENGTH_SHORT);
            // style the snackbar text
            TextView sbText = sb.getView().findViewById(com.google.android.material.R.id.snackbar_text);
            sbText.setTextColor(ThemeUtils.getThemeColor(this, R.attr.odyssey_color_text_accent));
            sb.show();
        }
    } catch (RemoteException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
 

private void onFlag(long id) {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    boolean threading = prefs.getBoolean("threading", true);

    DB db = DB.getInstance(this);
    try {
        db.beginTransaction();

        EntityMessage message = db.message().getMessage(id);
        if (message == null)
            return;

        List<EntityMessage> messages = db.message().getMessagesByThread(
                message.account, message.thread, threading ? null : id, message.folder);
        for (EntityMessage threaded : messages) {
            EntityOperation.queue(this, threaded, EntityOperation.FLAG, true);
            EntityOperation.queue(this, threaded, EntityOperation.SEEN, true);
        }

        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
}
 

@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
    setPreferencesFromResource(R.xml.measurement_preferences, rootKey);

    setHasOptionsMenu(true);

    Preference deleteAll = findPreference(PREFERENCE_KEY_DELETE_ALL);
    deleteAll.setOnPreferenceClickListener(new onClickListenerDeleteAll());

    measurementCategory = (PreferenceCategory) findPreference(PREFERENCE_KEY_MEASUREMENTS);

    Preference resetOrder = findPreference(PREFERENCE_KEY_RESET_ORDER);
    resetOrder.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {
            PreferenceManager.getDefaultSharedPreferences(getActivity()).edit()
                    .remove(MeasurementView.PREF_MEASUREMENT_ORDER).apply();
            updateMeasurementPreferences();
            return true;
        }
    });

    updateMeasurementPreferences();
}
 

@Override
protected void onResume() {
    super.onResume();

    checkPermissions(null);

    // Listen for preference changes
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    prefs.registerOnSharedPreferenceChangeListener(this);

    // Listen for interactive state changes
    IntentFilter ifInteractive = new IntentFilter();
    ifInteractive.addAction(Intent.ACTION_SCREEN_ON);
    ifInteractive.addAction(Intent.ACTION_SCREEN_OFF);
    registerReceiver(interactiveStateReceiver, ifInteractive);

    // Listen for connectivity updates
    IntentFilter ifConnectivity = new IntentFilter();
    ifConnectivity.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(connectivityChangedReceiver, ifConnectivity);
}
 

public void generateNewAddress() {
    WalletAddressUnusedTask task = new WalletAddressUnusedTask(new WalletAddressUnusedTask.WalletAddressUnusedHandler() {
        @Override
        public void beforeStart() {
            Helper.setViewEnabled(buttonGetNewAddress, false);
        }
        @Override
        public void onSuccess(String newAddress) {
            Context context = getContext();
            if (context != null) {
                SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
                sp.edit().putString(MainActivity.PREFERENCE_KEY_INTERNAL_WALLET_RECEIVE_ADDRESS, newAddress).apply();
            }
            Helper.setViewText(textWalletReceiveAddress, newAddress);
            Helper.setViewEnabled(buttonGetNewAddress, true);
        }

        @Override
        public void onError(Exception error) {
            Helper.setViewEnabled(buttonGetNewAddress, true);
        }
    });
    task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
 

@TargetApi(Build.VERSION_CODES.M)
private boolean checkPermissions(String name) {
    PreferenceScreen screen = getPreferenceScreen();
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

    // Check if permission was revoked
    if ((name == null || "disable_on_call".equals(name)) && prefs.getBoolean("disable_on_call", false))
        if (!Util.hasPhoneStatePermission(this)) {
            prefs.edit().putBoolean("disable_on_call", false).apply();
            ((TwoStatePreference) screen.findPreference("disable_on_call")).setChecked(false);

            requestPermissions(new String[]{Manifest.permission.READ_PHONE_STATE}, REQUEST_CALL);

            if (name != null)
                return false;
        }

    return true;
}
 

static void init(Context context, boolean immediately) {
    try {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        boolean fts = prefs.getBoolean("fts", true);
        boolean pro = ActivityBilling.isPro(context);
        if (fts && pro) {
            Log.i("Queuing " + getName());

            OneTimeWorkRequest.Builder builder = new OneTimeWorkRequest.Builder(WorkerFts.class);
            if (!immediately)
                builder.setInitialDelay(INDEX_DELAY, TimeUnit.SECONDS);
            OneTimeWorkRequest workRequest = builder.build();

            WorkManager.getInstance(context)
                    .enqueueUniqueWork(getName(), ExistingWorkPolicy.REPLACE, workRequest);

            Log.i("Queued " + getName());
        } else if (immediately)
            cancel(context);
    } catch (IllegalStateException ex) {
        // https://issuetracker.google.com/issues/138465476
        Log.w(ex);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Toolbar toolbar = findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);

    FloatingActionButton fab = findViewById(R.id.fab);
    fab.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent intent = new Intent(MainActivity.this, OrderActivity.class);
            intent.putExtra(EXTRA_MESSAGE, mOrderMessage);
            startActivity(intent);
        }
    });

    PreferenceManager.setDefaultValues(this, R.xml.sync_preferences, false);
    PreferenceManager.setDefaultValues(this, R.xml.general_preferences, false);
    PreferenceManager.setDefaultValues(this, R.xml.notification_preferences, false);
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    String marketPref = sharedPreferences.getString("sync_frequency", "-1");
    displayToast(marketPref);
}
 

private void startStats() {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ServiceSinkhole.this);
    boolean enabled = (!stats && prefs.getBoolean("show_stats", false));
    Log.i(TAG, "Stats start enabled=" + enabled);
    if (enabled) {
        when = new Date().getTime();
        t = -1;
        tx = -1;
        rx = -1;
        gt.clear();
        gtx.clear();
        grx.clear();
        mapUidBytes.clear();
        stats = true;
        updateStats();
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    fetchArchivesFromNetwork();

    final String startActivityPref = getString(R.string.start_activity_pref);
    final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

    final String act = prefs.getString(startActivityPref, getDefaultStartupActivity());
    final Class c = startupActivities.get(act) == null ? startupActivities.get(getDefaultStartupActivity()) : startupActivities.get(act);

    final Bundle args = getIntent().getExtras();
    final Intent i = new Intent(this, c);

    if (args != null) {
        i.putExtras(args);
    }
    startActivity(i);

    finish();
}
 

@Override
protected void onResume() {
    super.onResume();

    checkPermissions(null);

    // Listen for preference changes
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    prefs.registerOnSharedPreferenceChangeListener(this);

    // Listen for interactive state changes
    IntentFilter ifInteractive = new IntentFilter();
    ifInteractive.addAction(Intent.ACTION_SCREEN_ON);
    ifInteractive.addAction(Intent.ACTION_SCREEN_OFF);
    registerReceiver(interactiveStateReceiver, ifInteractive);

    // Listen for connectivity updates
    IntentFilter ifConnectivity = new IntentFilter();
    ifConnectivity.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(connectivityChangedReceiver, ifConnectivity);
}
 

private void onExit() {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
    boolean setup_reminder = prefs.getBoolean("setup_reminder", true);

    boolean hasPermissions = hasPermission(Manifest.permission.READ_CONTACTS);
    Boolean isIgnoring = Helper.isIgnoringOptimizations(getContext());

    if (!setup_reminder ||
            (hasPermissions && (isIgnoring == null || isIgnoring)))
        super.finish();
    else {
        FragmentDialogStill fragment = new FragmentDialogStill();
        fragment.setTargetFragment(this, ActivitySetup.REQUEST_STILL);
        fragment.show(getParentFragmentManager(), "setup:still");
    }
}
 

private DatabaseHelper(Context context) {
    super(context, DB_NAME, null, DB_VERSION);
    prefs = PreferenceManager.getDefaultSharedPreferences(context);

    if (!once) {
        once = true;

        File dbfile = context.getDatabasePath(DB_NAME);
        if (dbfile.exists()) {
            Log.w(TAG, "Deleting " + dbfile);
            dbfile.delete();
        }

        File dbjournal = context.getDatabasePath(DB_NAME + "-journal");
        if (dbjournal.exists()) {
            Log.w(TAG, "Deleting " + dbjournal);
            dbjournal.delete();
        }
    }
}
 

private ArtworkManager(Context context) {

        mDBManager = ArtworkDatabaseManager.getInstance(context);

        mArtistListeners = new ArrayList<>();
        mAlbumListeners = new ArrayList<>();

        ConnectionStateReceiver receiver = new ConnectionStateReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        context.registerReceiver(receiver, filter);

        SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(context);
        mArtistProvider = sharedPref.getString(context.getString(R.string.pref_artist_provider_key), context.getString(R.string.pref_artwork_provider_artist_default));
        mAlbumProvider = sharedPref.getString(context.getString(R.string.pref_album_provider_key), context.getString(R.string.pref_artwork_provider_album_default));
        mWifiOnly = sharedPref.getBoolean(context.getString(R.string.pref_download_wifi_only_key), context.getResources().getBoolean(R.bool.pref_download_wifi_default));
        mUseLocalImages = sharedPref.getBoolean(context.getString(R.string.pref_artwork_use_local_images_key), context.getResources().getBoolean(R.bool.pref_artwork_use_local_images_default));
    }
 

AdapterAccount(final Fragment parentFragment, boolean settings) {
    this.parentFragment = parentFragment;
    this.settings = settings;

    this.context = parentFragment.getContext();
    this.owner = parentFragment.getViewLifecycleOwner();
    this.inflater = LayoutInflater.from(context);

    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
    boolean highlight_unread = prefs.getBoolean("highlight_unread", true);
    this.colorUnread = Helper.resolveColor(context, highlight_unread ? R.attr.colorUnreadHighlight : android.R.attr.textColorPrimary);
    this.textColorSecondary = Helper.resolveColor(context, android.R.attr.textColorSecondary);

    this.DTF = Helper.getDateTimeInstance(context, DateFormat.SHORT, DateFormat.SHORT);

    setHasStableIds(true);

    owner.getLifecycle().addObserver(new LifecycleObserver() {
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        public void onDestroyed() {
            Log.d(AdapterAccount.this + " parent destroyed");
            AdapterAccount.this.parentFragment = null;
        }
    });
}
 

private void onMenuDefault() {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
    SharedPreferences.Editor editor = prefs.edit();
    for (String option : RESET_OPTIONS)
        editor.remove(option);
    editor.apply();
    ToastEx.makeText(getContext(), R.string.title_setup_done, Toast.LENGTH_LONG).show();
}
 

protected SerializablePreferenceNullable(@NonNull Context context,
                                         @NonNull String key,
                                         @Nullable Serializable defaultValue) {
    this.preferences = PreferenceManager.getDefaultSharedPreferences(context);
    this.key = key;
    this.defaultObject = defaultValue;
    this.defaultValue = objectToString(defaultValue);
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	PreferenceManager.setDefaultValues(this, R.xml.preferences, false);

	ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());
	setContentView(binding.getRoot());

	viewPager = binding.viewPager;
	searchView = binding.search;
	navigationView = binding.navView;
	drawerLayout = binding.layoutDrawer;

	setSupportActionBar(binding.toolbar);

	ActionBar actionbar = getSupportActionBar();
	actionbar.setDisplayHomeAsUpEnabled(true);
	actionbar.setHomeAsUpIndicator(R.drawable.ic_menu_white_24dp);

	viewPager.setAdapter(new MainPageAdapter(getSupportFragmentManager()));
	viewPager.addOnPageChangeListener(this);

	searchView.setOnQueryTextListener(this);
	SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
	searchView.setIconified(false);
	searchView.setIconifiedByDefault(false);
	searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
	searchView.clearFocus();
	searchView.setOnQueryTextFocusChangeListener(this::onSearchQueryTextFocusChangeListener);

	navigationView.setNavigationItemSelectedListener(this::onNavigationItemSelected);

	onPageSelected(viewPager.getCurrentItem());

	handleIntent(getIntent());
}
 

@Override
public void onApi(boolean valid, Exception error) {
	if (valid) {
		// Clear the database
		final DaoStore daoStore = DaoStore.getInstance(getApplicationContext());
		if (!daoStore.isDatabaseEmpty()) {
			daoStore.resetDatabase();
		}

		SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
		SharedPreferences.Editor editor = sharedPreferences.edit();
		editor.putString(getString(R.string.serverURLKey), serverUrlTextView.getText().toString()).apply();

		// finish this activity back to the login activity
		done();
	} else {
		apiStatusView.setVisibility(View.GONE);
		serverUrlForm.setVisibility(View.VISIBLE);
		serverUrlButton.setEnabled(true);

		String message = "Cannot connect to server.";
		if (error == null) {
			message = "Application is not compatible with server.";

			new AlertDialog.Builder(this)
					.setTitle("Compatibility Error")
					.setMessage("Your MAGE application is not compatibile with this server.  Please update your application or contact your MAGE administrator for support.")
					.setPositiveButton(android.R.string.ok, null)
					.create()
					.show();
		} else {
			if (error.getCause() != null) {
				message = error.getCause().getMessage();
			}
		}

		serverUrlLayout.setError(message);
	}
}
 

public void onPause() {
    Context context = getContext();
    if (context != null) {
        ((MainActivity) context).removeDownloadActionListener(this);
    }
    PreferenceManager.getDefaultSharedPreferences(context).registerOnSharedPreferenceChangeListener(this);
    super.onPause();
}
 

private void updateColor() {
    Context context = getContext();
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
    boolean identicons = prefs.getBoolean("identicons", false);
    boolean circular = prefs.getBoolean("circular", true);

    int size = Helper.dp2pixels(context, 36);
    byte[] ahash = ImageHelper.getHash("[email protected]");
    byte[] bhash = ImageHelper.getHash("[email protected]");
    byte[] chash = ImageHelper.getHash("[email protected]");
    Integer radius = (circular && !identicons ? null : Helper.dp2pixels(context, 3));

    Bitmap red = (identicons
            ? ImageHelper.generateIdenticon(ahash, 0f, size, 5, context)
            : ImageHelper.generateLetterIcon("A", 0f, size, context));

    Bitmap green = (identicons
            ? ImageHelper.generateIdenticon(bhash, 120f, size, 5, context)
            : ImageHelper.generateLetterIcon("B", 120f, size, context));

    Bitmap blue = (identicons
            ? ImageHelper.generateIdenticon(chash, 240f, size, 5, context)
            : ImageHelper.generateLetterIcon("C", 240f, size, context));

    ivRed.setImageBitmap(ImageHelper.makeCircular(red, radius));
    ivGreen.setImageBitmap(ImageHelper.makeCircular(green, radius));
    ivBlue.setImageBitmap(ImageHelper.makeCircular(blue, radius));
}
 

private static boolean loginNow(Context context) {
    String uid = BaseDb.getInstance().getUid();
    if (TextUtils.isEmpty(uid)) {
        Log.w(TAG, "Data fetch failed: not logged in");
        // Unknown if data is available, assuming it is.
        return false;
    }

    final AccountManager am = AccountManager.get(context);
    final Account account = getSavedAccount(am, uid);
    if (account == null) {
        Log.w(TAG, "Data fetch failed: account not found");
        return false;
    }

    final SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(context);
    String hostName = sharedPref.getString(Utils.PREFS_HOST_NAME, TindroidApp.getDefaultHostName(context));
    boolean tls = sharedPref.getBoolean(Utils.PREFS_USE_TLS, TindroidApp.getDefaultTLS());

    final Tinode tinode = Cache.getTinode();

    try {
        // Will return immediately if it's already connected.
        tinode.connect(hostName, tls, true).getResult();

        String token = AccountManager.get(context).blockingGetAuthToken(account, Utils.TOKEN_TYPE, false);

        tinode.loginToken(token).getResult();
    }  catch (Exception ex) {
        Log.w(TAG, "Failed to connect to server", ex);
        return false;
    }

    return true;
}
 

@Override public void onSettingsChanged() {
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
    try {
        concert_a = Integer.parseInt(sp.getString("concert_a", "440"));
    } catch (NumberFormatException e) {
        concert_a = 440;
    }
}
 

@Override
public void onPrepareOptionsMenu(Menu menu) {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
    boolean subscriptions = prefs.getBoolean("subscriptions", false);
    boolean subscribed_only = prefs.getBoolean("subscribed_only", false);

    menu.findItem(R.id.menu_compact).setChecked(compact);
    menu.findItem(R.id.menu_show_hidden).setChecked(show_hidden);
    menu.findItem(R.id.menu_show_flagged).setChecked(show_flagged);
    menu.findItem(R.id.menu_subscribed_only).setChecked(subscribed_only);
    menu.findItem(R.id.menu_subscribed_only).setVisible(subscriptions);
    menu.findItem(R.id.menu_apply_all).setVisible(account >= 0);

    super.onPrepareOptionsMenu(menu);
}
 

public static void start(int frequency) {
    Context context = ITagApplication.context;
    final SharedPreferences preferences =
            PreferenceManager.getDefaultSharedPreferences(context);
    preferences.edit().putBoolean("wt", true).apply();
    preferences.edit().putInt("freq", frequency).apply();
    final String tid = preferences.getString("tid", null);
    if (BuildConfig.DEBUG) Log.d(LT, "start tid=" + tid+ " freq="+frequency);
    if (tid == null) {
        ITagApplication.faWtNoTrackID();
        if (BuildConfig.DEBUG) Log.d(LT, "will request tid");
        final IDService.IIDSeriviceListener listener = new IDService.IIDSeriviceListener() {
            @Override
            public void onTrackID(@NonNull String trackID) {
                IDService.removeOnTrackIDChangeListener(this);
                if (BuildConfig.DEBUG) Log.d(LT, "got new tid="+trackID);
                if (!"".equals(trackID)) {
                    // duplicate of ITagsService.onTrackID
                    preferences.edit().putString("tid", trackID).apply();
                    if (BuildConfig.DEBUG) Log.d(LT, "will request start after new tid");
                    handler.post(() ->
                            LocationsTracker.requestStart(gpsLocatonUpdater, frequency));
                }
            }
        };
        IDService.addOnTrackIDChangeListener(listener);
        IDService.enqueueRetrieveId(context, "");
    } else {
        if (BuildConfig.DEBUG) Log.d(LT, "will request start immediately");
        LocationsTracker.requestStart(gpsLocatonUpdater, frequency);
    }
}
 

private void setOptions() {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());

    swConfirmLinks.setChecked(prefs.getBoolean("confirm_links", true));
    swBrowseLinks.setChecked(prefs.getBoolean("browse_links", false));
    swBrowseLinks.setEnabled(!swConfirmLinks.isChecked());
    swConfirmImages.setChecked(prefs.getBoolean("confirm_images", true));
    swConfirmHtml.setChecked(prefs.getBoolean("confirm_html", true));
    swDisableTracking.setChecked(prefs.getBoolean("disable_tracking", true));
    swHideTimeZone.setChecked(prefs.getBoolean("hide_timezone", true));

    boolean biometrics = prefs.getBoolean("biometrics", false);
    btnBiometrics.setText(biometrics
            ? R.string.title_setup_biometrics_disable
            : R.string.title_setup_biometrics_enable);
    btnBiometrics.setEnabled(Helper.canAuthenticate(getContext()));

    int biometrics_timeout = prefs.getInt("biometrics_timeout", 2);
    int[] biometricTimeoutValues = getResources().getIntArray(R.array.biometricsTimeoutValues);
    for (int pos = 0; pos < biometricTimeoutValues.length; pos++)
        if (biometricTimeoutValues[pos] == biometrics_timeout) {
            spBiometricsTimeout.setSelection(pos);
            break;
        }

    swDisplayHidden.setChecked(prefs.getBoolean("display_hidden", false));
    swSecure.setChecked(prefs.getBoolean("secure", false));
    swSafeBrowsing.setChecked(prefs.getBoolean("safe_browsing", false));
}
 

private static void persist(Context context, String language) {
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = preferences.edit();

    editor.putString(SELECTED_LANGUAGE, language);
    editor.apply();
}
 

@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
    addPreferencesFromResource(R.xml.preferences);

    setHasOptionsMenu(true);
    context = getContext();

    sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);

    //this static call will reset default values only on the first ever read
    PreferenceManager.setDefaultValues(context, R.xml.preferences, false);

    cbRandomize = findPreference("RANDOMIZE_LOCATION");
}