|
|
|
/*
|
|
|
|
* Copyright 2010-2018 Eric Kok et al.
|
|
|
|
*
|
|
|
|
* Transdroid is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Transdroid is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Transdroid. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
package org.transdroid.core.app.settings;
|
|
|
|
|
|
|
|
import android.content.Context;
|
|
|
|
import android.content.SharedPreferences;
|
|
|
|
import android.content.SharedPreferences.Editor;
|
|
|
|
import android.text.TextUtils;
|
|
|
|
|
|
|
|
import androidx.preference.PreferenceManager;
|
|
|
|
|
|
|
|
import org.androidannotations.annotations.Bean;
|
|
|
|
import org.androidannotations.annotations.EBean;
|
|
|
|
import org.androidannotations.annotations.EBean.Scope;
|
|
|
|
import org.androidannotations.annotations.RootContext;
|
|
|
|
import org.json.JSONArray;
|
|
|
|
import org.json.JSONException;
|
|
|
|
import org.transdroid.core.app.search.SearchHelper;
|
|
|
|
import org.transdroid.core.app.search.SearchHelper.SearchSortOrder;
|
|
|
|
import org.transdroid.core.app.search.SearchSite;
|
|
|
|
import org.transdroid.core.gui.navigation.NavigationFilter;
|
|
|
|
import org.transdroid.core.gui.navigation.StatusType;
|
|
|
|
import org.transdroid.core.gui.search.SearchSetting;
|
|
|
|
import org.transdroid.core.seedbox.SeedboxProvider;
|
|
|
|
import org.transdroid.core.widget.ListWidgetConfig;
|
|
|
|
import org.transdroid.daemon.Daemon;
|
|
|
|
import org.transdroid.daemon.OS;
|
|
|
|
import org.transdroid.daemon.TorrentsSortBy;
|
|
|
|
|
|
|
|
import java.security.InvalidParameterException;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Date;
|
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Singleton object to access all application settings, including stored servers, web search sites and RSS feeds.
|
|
|
|
*
|
|
|
|
* @author Eric Kok
|
|
|
|
*/
|
|
|
|
@EBean(scope = Scope.Singleton)
|
|
|
|
public class ApplicationSettings {
|
|
|
|
|
|
|
|
public static final int DEFAULTSERVER_LASTUSED = -2;
|
|
|
|
public static final int DEFAULTSERVER_ASKONADD = -1;
|
|
|
|
|
|
|
|
@RootContext
|
|
|
|
protected Context context;
|
|
|
|
private SharedPreferences prefs;
|
|
|
|
@Bean
|
|
|
|
protected SearchHelper searchHelper;
|
|
|
|
|
|
|
|
protected ApplicationSettings(Context context) {
|
|
|
|
prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns all available user-configured normal and seed servers
|
|
|
|
*
|
|
|
|
* @return A list of all stored server settings objects
|
|
|
|
*/
|
|
|
|
public List<ServerSetting> getAllServerSettings() {
|
|
|
|
List<ServerSetting> all = new ArrayList<>();
|
|
|
|
all.addAll(getNormalServerSettings());
|
|
|
|
for (SeedboxProvider provider : SeedboxProvider.values()) {
|
|
|
|
all.addAll(provider.getSettings().getAllServerSettings(prefs, all.size()));
|
|
|
|
}
|
|
|
|
return all;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the order number/identifying key of the last server, normal or seedbox configured
|
|
|
|
*
|
|
|
|
* @return The zero-based order number (index) of the last stored server settings
|
|
|
|
*/
|
|
|
|
public int getMaxOfAllServers() {
|
|
|
|
int max = getMaxNormalServer();
|
|
|
|
for (SeedboxProvider provider : SeedboxProvider.values()) {
|
|
|
|
max += provider.getSettings().getMaxSeedboxOrder(prefs) + 1;
|
|
|
|
}
|
|
|
|
return max;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the server settings for either a normal or a seedbox server as the user configured. WARNING: This method
|
|
|
|
* does not check if the settings actually exist and may reply on empty default if called for a non-existing server.
|
|
|
|
*
|
|
|
|
* @param order The order number/identifying key of the server's settings to retrieve, where the normal servers are
|
|
|
|
* first and the seedboxes are numbers thereafter onwards
|
|
|
|
* @return The server settings object, loaded from shared preferences
|
|
|
|
*/
|
|
|
|
public ServerSetting getServerSetting(int order) {
|
|
|
|
int max = getMaxNormalServer() + 1;
|
|
|
|
if (order < max) {
|
|
|
|
return getNormalServerSetting(order);
|
|
|
|
}
|
|
|
|
for (SeedboxProvider provider : SeedboxProvider.values()) {
|
|
|
|
int offset = max;
|
|
|
|
max += provider.getSettings().getMaxSeedboxOrder(prefs) + 1;
|
|
|
|
if (order < max) {
|
|
|
|
return provider.getSettings().getServerSetting(prefs, offset, order - offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns all available normal, user-configured servers (so no seedbox settings)
|
|
|
|
*
|
|
|
|
* @return A list of all stored server settings objects
|
|
|
|
*/
|
|
|
|
public List<ServerSetting> getNormalServerSettings() {
|
|
|
|
List<ServerSetting> servers = new ArrayList<>();
|
|
|
|
for (int i = 0; i <= getMaxNormalServer(); i++) {
|
|
|
|
servers.add(getNormalServerSetting(i));
|
|
|
|
}
|
|
|
|
return Collections.unmodifiableList(servers);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the order number/identifying key of the last normal server
|
|
|
|
*
|
|
|
|
* @return The zero-based order number (index) of the last stored normal server settings
|
|
|
|
*/
|
|
|
|
public int getMaxNormalServer() {
|
|
|
|
for (int i = 0; true; i++) {
|
|
|
|
if (prefs.getString("server_type_" + i, null) == null || prefs.getString("server_address_" + i, null) == null)
|
|
|
|
return i - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the user-specified server settings for a normal (non-seedbox) server. WARNING: This method does not check
|
|
|
|
* if the settings actually exist and may rely on empty defaults if called for a non-existing server.
|
|
|
|
*
|
|
|
|
* @param order The order number/identifying key of the normal server's settings to retrieve
|
|
|
|
* @return The server settings object, loaded from shared preferences
|
|
|
|
*/
|
|
|
|
public ServerSetting getNormalServerSetting(int order) {
|
|
|
|
// @formatter:off
|
|
|
|
Daemon type = Daemon.fromCode(prefs.getString("server_type_" + order, null));
|
|
|
|
boolean ssl = prefs.getBoolean("server_sslenabled_" + order, false);
|
|
|
|
boolean localSsl = prefs.getBoolean("server_localsslenabled_" + order, ssl);
|
|
|
|
|
|
|
|
String port = prefs.getString("server_port_" + order, null);
|
|
|
|
if (TextUtils.isEmpty(port))
|
|
|
|
port = Integer.toString(Daemon.getDefaultPortNumber(type, ssl));
|
|
|
|
String localPort = prefs.getString("server_localport_" + order, null);
|
|
|
|
if (TextUtils.isEmpty(localPort))
|
|
|
|
localPort = port; // Default to the normal (non-local) port
|
|
|
|
try {
|
|
|
|
parseInt(port, Daemon.getDefaultPortNumber(type, ssl));
|
|
|
|
} catch (NumberFormatException e) {
|
|
|
|
port = Integer.toString(Daemon.getDefaultPortNumber(type, ssl));
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
parseInt(localPort, parseInt(port, Daemon.getDefaultPortNumber(type, ssl)));
|
|
|
|
} catch (NumberFormatException e) {
|
|
|
|
localPort = port;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new ServerSetting(order,
|
|
|
|
prefs.getString("server_name_" + order, null),
|
|
|
|
type,
|
|
|
|
trim(prefs.getString("server_address_" + order, null)),
|
|
|
|
trim(prefs.getString("server_localaddress_" + order, null)),
|
|
|
|
parseInt(localPort, parseInt(port, Daemon.getDefaultPortNumber(type, ssl))),
|
|
|
|
prefs.getString("server_localnetwork_" + order, null),
|
|
|
|
parseInt(port, Daemon.getDefaultPortNumber(type, ssl)),
|
|
|
|
ssl, localSsl,
|
|
|
|
prefs.getBoolean("server_ssltrustall_" + order, false),
|
|
|
|
prefs.getString("server_ssltrustkey_" + order, null),
|
|
|
|
prefs.getString("server_folder_" + order, null),
|
|
|
|
!prefs.getBoolean("server_disableauth_" + order, false),
|
|
|
|
prefs.getString("server_user_" + order, null),
|
|
|
|
prefs.getString("server_pass_" + order, null),
|
|
|
|
prefs.getString("server_extrapass_" + order, null),
|
|
|
|
OS.fromCode(prefs.getString("server_os_" + order, "type_linux")),
|
|
|
|
prefs.getString("server_downloaddir_" + order, null),
|
|
|
|
prefs.getString("server_ftpurl_" + order, null),
|
|
|
|
prefs.getString("server_ftppass_" + order, null),
|
|
|
|
parseInt(prefs.getString("server_timeout_" + order, "8"), 8),
|
|
|
|
prefs.getBoolean("server_alarmfinished_" + order, true),
|
|
|
|
prefs.getBoolean("server_alarmnew_" + order, false),
|
|
|
|
prefs.getString("server_alarmexclude_" + order, null),
|
|
|
|
prefs.getString("server_alarminclude_" + order, null),
|
|
|
|
false);
|
|
|
|
// @formatter:on
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes all settings related to a configured server. Since servers are ordered, the order of the remaining
|
|
|
|
* servers will be updated accordingly.
|
|
|
|
*
|
|
|
|
* @param order The identifying order number/key of the settings to remove
|
|
|
|
*/
|
|
|
|
public void removeNormalServerSettings(int order) {
|
|
|
|
if (prefs.getString("server_type_" + order, null) == null)
|
|
|
|
return; // The settings that were requested to be removed do not exist
|
|
|
|
|
|
|
|
// Copy all settings higher than the supplied order number to the previous spot
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
int max = getMaxNormalServer();
|
|
|
|
for (int i = order; i < max; i++) {
|
|
|
|
edit.putString("server_name_" + i, prefs.getString("server_name_" + (i + 1), null));
|
|
|
|
edit.putString("server_type_" + i, prefs.getString("server_type_" + (i + 1), null));
|
|
|
|
edit.putString("server_address_" + i, prefs.getString("server_address_" + (i + 1), null));
|
|
|
|
edit.putString("server_localaddress_" + i, prefs.getString("server_localaddress_" + (i + 1), null));
|
|
|
|
edit.putString("server_localnetwork_" + i, prefs.getString("server_localnetwork_" + (i + 1), null));
|
|
|
|
edit.putString("server_port_" + i, prefs.getString("server_port_" + (i + 1), null));
|
|
|
|
edit.putBoolean("server_sslenabled_" + i, prefs.getBoolean("server_sslenabled_" + (i + 1), false));
|
|
|
|
edit.putBoolean("server_localsslenabled_" + i, prefs.getBoolean("server_localsslenabled_" + (i + 1), false));
|
|
|
|
edit.putBoolean("server_ssltrustall_" + i, prefs.getBoolean("server_ssltrustall_" + (i + 1), false));
|
|
|
|
edit.putString("server_ssltrustkey_" + i, prefs.getString("server_ssltrustkey_" + (i + 1), null));
|
|
|
|
edit.putString("server_folder_" + i, prefs.getString("server_folder_" + (i + 1), null));
|
|
|
|
edit.putBoolean("server_disableauth_" + i, prefs.getBoolean("server_disableauth_" + (i + 1), false));
|
|
|
|
edit.putString("server_user_" + i, prefs.getString("server_user_" + (i + 1), null));
|
|
|
|
edit.putString("server_pass_" + i, prefs.getString("server_pass_" + (i + 1), null));
|
|
|
|
edit.putString("server_extrapass_" + i, prefs.getString("server_extrapass_" + (i + 1), null));
|
|
|
|
edit.putString("server_os_" + i, prefs.getString("server_os_" + (i + 1), null));
|
|
|
|
edit.putString("server_downloaddir_" + i, prefs.getString("server_downloaddir_" + (i + 1), null));
|
|
|
|
edit.putString("server_ftpurl_" + i, prefs.getString("server_ftpurl_" + (i + 1), null));
|
|
|
|
edit.putString("server_ftppass_" + i, prefs.getString("server_ftppass_" + (i + 1), null));
|
|
|
|
edit.putString("server_timeout_" + i, prefs.getString("server_timeout_" + (i + 1), null));
|
|
|
|
edit.putBoolean("server_alarmfinished_" + i, prefs.getBoolean("server_alarmfinished_" + (i + 1), true));
|
|
|
|
edit.putBoolean("server_alarmfinished_" + i, prefs.getBoolean("server_alarmfinished_" + (i + 1), false));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the last settings, of which we are now sure are no longer required
|
|
|
|
edit.remove("server_name_" + max);
|
|
|
|
edit.remove("server_type_" + max);
|
|
|
|
edit.remove("server_address_" + max);
|
|
|
|
edit.remove("server_localaddress_" + max);
|
|
|
|
edit.remove("server_localnetwork_" + max);
|
|
|
|
edit.remove("server_port_" + max);
|
|
|
|
edit.remove("server_sslenabled_" + max);
|
|
|
|
edit.remove("server_localsslenabled_" + max);
|
|
|
|
edit.remove("server_ssltrustall_" + max);
|
|
|
|
edit.remove("server_ssltrustkey_" + max);
|
|
|
|
edit.remove("server_folder_" + max);
|
|
|
|
edit.remove("server_disableauth_" + max);
|
|
|
|
edit.remove("server_user_" + max);
|
|
|
|
edit.remove("server_pass_" + max);
|
|
|
|
edit.remove("server_extrapass_" + max);
|
|
|
|
edit.remove("server_os_" + max);
|
|
|
|
edit.remove("server_downloaddir_" + max);
|
|
|
|
edit.remove("server_ftpurl_" + max);
|
|
|
|
edit.remove("server_ftppass_" + max);
|
|
|
|
edit.remove("server_timeout_" + max);
|
|
|
|
edit.remove("server_alarmfinished_" + max);
|
|
|
|
edit.remove("server_alarmfinished_" + max);
|
|
|
|
|
|
|
|
// Perhaps we should also update the default server to match the server's new id or remove the default selection
|
|
|
|
// in case it was this server that was removed
|
|
|
|
int defaultServer = getDefaultServerKey();
|
|
|
|
if (defaultServer == order) {
|
|
|
|
edit.remove("header_defaultserver");
|
|
|
|
} else if (defaultServer > order) {
|
|
|
|
// Move 'up' one place to account for the removed server setting
|
|
|
|
edit.putString("header_defaultserver", String.valueOf(--order));
|
|
|
|
}
|
|
|
|
|
|
|
|
edit.apply();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the settings of the server that was explicitly selected by the user to select as default or, when no
|
|
|
|
* specific default server was selected, the last used server settings. As opposed to getDefaultServerKey(int), this
|
|
|
|
* method checks whether the particular server still exists (and returns the first server if not). If no servers are
|
|
|
|
* configured, null is returned.
|
|
|
|
*
|
|
|
|
* @return A server settings object of the server to use by default, or null if no server is yet configured
|
|
|
|
*/
|
|
|
|
public ServerSetting getDefaultServer() {
|
|
|
|
|
|
|
|
int defaultServer = getDefaultServerKey();
|
|
|
|
if (defaultServer == DEFAULTSERVER_LASTUSED || defaultServer == DEFAULTSERVER_ASKONADD) {
|
|
|
|
return getLastUsedServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use the explicitly selected default server
|
|
|
|
int max = getMaxOfAllServers(); // Zero-based index, so with max == 0 there is 1 server
|
|
|
|
if (max < 0) {
|
|
|
|
// No servers configured
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
if (defaultServer < 0 || defaultServer > max) {
|
|
|
|
// Last server was never set or no longer exists
|
|
|
|
return getServerSetting(0);
|
|
|
|
}
|
|
|
|
return getServerSetting(defaultServer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the unique key of the server setting that the user selected as their default server, or code indicating
|
|
|
|
* that the last used server should be selected by default; use with getDefaultServer directly. WARNING: the
|
|
|
|
* returned string may no longer refer to a known server setting key.
|
|
|
|
*
|
|
|
|
* @return An integer; if it is 0 or higher it represents the unique key of a configured server setting, -2 means
|
|
|
|
* the last used server should be selected as default instead and -1 means the last used server should be
|
|
|
|
* selected by default for viewing yet it should always ask when adding a new torrent
|
|
|
|
*/
|
|
|
|
public int getDefaultServerKey() {
|
|
|
|
String defaultServer = prefs.getString("header_defaultserver", Integer.toString(DEFAULTSERVER_LASTUSED));
|
|
|
|
try {
|
|
|
|
return Integer.parseInt(defaultServer);
|
|
|
|
} catch (NumberFormatException e) {
|
|
|
|
// This should NEVER happen but if the setting somehow is not a number, return the default
|
|
|
|
return DEFAULTSERVER_LASTUSED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the settings of the server that was last used by the user. As opposed to getLastUsedServerKey(int), this
|
|
|
|
* method checks whether a server was already registered as being last used and check whether the server still
|
|
|
|
* exists. It returns the first server if that fails. If no servers are configured, null is returned.
|
|
|
|
*
|
|
|
|
* @return A server settings object of the last used server (or, if not known, the first server), or null if no
|
|
|
|
* servers exist
|
|
|
|
*/
|
|
|
|
public ServerSetting getLastUsedServer() {
|
|
|
|
int max = getMaxOfAllServers(); // Zero-based index, so with max == 0 there is 1 server
|
|
|
|
if (max < 0) {
|
|
|
|
// No servers configured
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
int last = getLastUsedServerKey();
|
|
|
|
if (last < 0 || last > max) {
|
|
|
|
// Last server was never set or no longer exists
|
|
|
|
return getServerSetting(0);
|
|
|
|
}
|
|
|
|
return getServerSetting(last);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the order number/unique key of the server that the used last used; use with getServerSettings(int) or
|
|
|
|
* call getLastUsedServer directly. WARNING: the returned integer may no longer refer to a known server settings
|
|
|
|
* object: check the bounds.
|
|
|
|
*
|
|
|
|
* @return An integer indicating the order number/key or the last used server, or -1 if it was not set
|
|
|
|
*/
|
|
|
|
public int getLastUsedServerKey() {
|
|
|
|
return prefs.getInt("system_lastusedserver", -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers some server as being the last used by the user
|
|
|
|
*
|
|
|
|
* @param server The settings of the server that the user last used
|
|
|
|
*/
|
|
|
|
public void setLastUsedServer(ServerSetting server) {
|
|
|
|
setLastUsedServerKey(server.getOrder());
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers the order number/unique key of some server as being last used by the user
|
|
|
|
*
|
|
|
|
* @param order The key identifying the specific server
|
|
|
|
*/
|
|
|
|
public void setLastUsedServerKey(int order) {
|
|
|
|
prefs.edit().putInt("system_lastusedserver", order).apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the unique code that (should) uniquely identify a navigation filter, such as a label, in the list of all
|
|
|
|
* available filters
|
|
|
|
*
|
|
|
|
* @return A code that the last used navigation filter reported as uniquely identifying itself, or null if no last
|
|
|
|
* used filter is known
|
|
|
|
*/
|
|
|
|
public String getLastUsedNavigationFilter() {
|
|
|
|
return prefs.getString("system_lastusedfilter", null);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers some navigation filter as being the last used by the user
|
|
|
|
*
|
|
|
|
* @param filter The navigation filter that the user last used in the interface
|
|
|
|
*/
|
|
|
|
public void setLastUsedNavigationFilter(NavigationFilter filter) {
|
|
|
|
prefs.edit().putString("system_lastusedfilter", filter.getCode()).apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns all available user-configured web-based (as opped to in-app) search sites
|
|
|
|
*
|
|
|
|
* @return A list of all stored web search site settings objects
|
|
|
|
*/
|
|
|
|
public List<WebsearchSetting> getWebsearchSettings() {
|
|
|
|
List<WebsearchSetting> websearches = new ArrayList<>();
|
|
|
|
for (int i = 0; i <= getMaxWebsearch(); i++) {
|
|
|
|
websearches.add(getWebsearchSetting(i));
|
|
|
|
}
|
|
|
|
return Collections.unmodifiableList(websearches);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the order number/identifying key of the last web search site
|
|
|
|
*
|
|
|
|
* @return The zero-based order number (index) of the last stored web search site
|
|
|
|
*/
|
|
|
|
public int getMaxWebsearch() {
|
|
|
|
for (int i = 0; true; i++) {
|
|
|
|
if (prefs.getString("websearch_baseurl_" + i, null) == null)
|
|
|
|
return i - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the user-specified web-based search site setting for a specific site
|
|
|
|
*
|
|
|
|
* @param order The order number/identifying key of the settings to retrieve
|
|
|
|
* @return The web search site settings object, loaded from shared preferences
|
|
|
|
*/
|
|
|
|
public WebsearchSetting getWebsearchSetting(int order) {
|
|
|
|
// @formatter:off
|
|
|
|
return new WebsearchSetting(order,
|
|
|
|
prefs.getString("websearch_name_" + order, null),
|
|
|
|
prefs.getString("websearch_baseurl_" + order, null),
|
|
|
|
prefs.getString("websearch_cookies_" + order, null));
|
|
|
|
// @formatter:on
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes all settings related to a configured web-based search site. Since sites are ordered, the order of the
|
|
|
|
* remaining sites will be updated accordingly.
|
|
|
|
*
|
|
|
|
* @param order The identifying order number/key of the settings to remove
|
|
|
|
*/
|
|
|
|
public void removeWebsearchSettings(int order) {
|
|
|
|
if (prefs.getString("websearch_baseurl_" + order, null) == null)
|
|
|
|
return; // The settings that were requested to be removed do not exist
|
|
|
|
|
|
|
|
// Copy all settings higher than the supplied order number to the previous spot
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
int max = getMaxWebsearch();
|
|
|
|
for (int i = order; i < max; i++) {
|
|
|
|
edit.putString("websearch_name_" + i, prefs.getString("websearch_name_" + (i + 1), null));
|
|
|
|
edit.putString("websearch_baseurl_" + i, prefs.getString("websearch_baseurl_" + (i + 1), null));
|
|
|
|
edit.putString("websearch_cookies_" + i, prefs.getString("websearch_cookies_" + (i + 1), null));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the last settings, of which we are now sure are no longer required
|
|
|
|
edit.remove("websearch_name_" + max);
|
|
|
|
edit.remove("websearch_baseurl_" + max);
|
|
|
|
edit.remove("websearch_cookies_" + max);
|
|
|
|
edit.apply();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns all available user-configured RSS feeds
|
|
|
|
*
|
|
|
|
* @return A list of all stored RSS feed settings objects
|
|
|
|
*/
|
|
|
|
public List<RssfeedSetting> getRssfeedSettings() {
|
|
|
|
List<RssfeedSetting> rssfeeds = new ArrayList<>();
|
|
|
|
for (int i = 0; i <= getMaxRssfeed(); i++) {
|
|
|
|
rssfeeds.add(getRssfeedSetting(i));
|
|
|
|
}
|
|
|
|
return Collections.unmodifiableList(rssfeeds);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the order number/identifying key of the last stored RSS feed
|
|
|
|
*
|
|
|
|
* @return The zero-based order number (index) of the last stored RSS feed
|
|
|
|
*/
|
|
|
|
public int getMaxRssfeed() {
|
|
|
|
for (int i = 0; true; i++) {
|
|
|
|
if (prefs.getString("rssfeed_url_" + i, null) == null)
|
|
|
|
return i - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the user-specified RSS feed setting for a specific feed
|
|
|
|
*
|
|
|
|
* @param order The order number/identifying key of the settings to retrieve
|
|
|
|
* @return The RSS feed settings object, loaded from shared preferences
|
|
|
|
*/
|
|
|
|
public RssfeedSetting getRssfeedSetting(int order) {
|
|
|
|
// @formatter:off
|
|
|
|
long lastViewed = prefs.getLong("rssfeed_lastviewed_" + order, -1);
|
|
|
|
return new RssfeedSetting(order,
|
|
|
|
prefs.getString("rssfeed_name_" + order, null),
|
|
|
|
prefs.getString("rssfeed_url_" + order, null),
|
|
|
|
prefs.getBoolean("rssfeed_reqauth_" + order, false),
|
|
|
|
prefs.getBoolean("rssfeed_alarmnew_" + order, true),
|
|
|
|
prefs.getString("rssfeed_exclude_" + order, null),
|
|
|
|
prefs.getString("rssfeed_include_" + order, null),
|
|
|
|
lastViewed == -1L ? null : new Date(lastViewed),
|
|
|
|
prefs.getString("rssfeed_lastvieweditemurl_" + order, null));
|
|
|
|
// @formatter:on
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes all settings related to a configured RSS feed. Since feeds are ordered, the order of the remaining feeds
|
|
|
|
* will be updated accordingly.
|
|
|
|
*
|
|
|
|
* @param order The identifying order number/key of the settings to remove
|
|
|
|
*/
|
|
|
|
public void removeRssfeedSettings(int order) {
|
|
|
|
if (prefs.getString("rssfeed_url_" + order, null) == null)
|
|
|
|
return; // The settings that were requested to be removed do not exist
|
|
|
|
|
|
|
|
// Copy all settings higher than the supplied order number to the previous spot
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
int max = getMaxRssfeed();
|
|
|
|
for (int i = order; i < max; i++) {
|
|
|
|
edit.putString("rssfeed_name_" + i, prefs.getString("rssfeed_name_" + (i + 1), null));
|
|
|
|
edit.putString("rssfeed_url_" + i, prefs.getString("rssfeed_url_" + (i + 1), null));
|
|
|
|
edit.putBoolean("rssfeed_reqauth_" + i, prefs.getBoolean("rssfeed_reqauth_" + (i + 1), false));
|
|
|
|
edit.putBoolean("rssfeed_alarmnew_" + i, prefs.getBoolean("rssfeed_alarmnew_" + (i + 1), true));
|
|
|
|
edit.putString("rssfeed_exclude_" + i, prefs.getString("rssfeed_exclude_" + (i + 1), null));
|
|
|
|
edit.putString("rssfeed_include_" + i, prefs.getString("rssfeed_include_" + (i + 1), null));
|
|
|
|
edit.putLong("rssfeed_lastviewed_" + i, prefs.getLong("rssfeed_lastviewed_" + (i + 1), -1));
|
|
|
|
edit.putString("rssfeed_lastvieweditemurl_" + i, prefs.getString("rssfeed_lastvieweditemurl_" + (i + 1), null));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the last settings, of which we are now sure are no longer required
|
|
|
|
edit.remove("rssfeed_name_" + max);
|
|
|
|
edit.remove("rssfeed_url_" + max);
|
|
|
|
edit.remove("rssfeed_reqauth_" + max);
|
|
|
|
edit.remove("rssfeed_alarmnew_" + max);
|
|
|
|
edit.remove("rssfeed_exclude_" + max);
|
|
|
|
edit.remove("rssfeed_include_" + max);
|
|
|
|
edit.remove("rssfeed_lastviewed_" + max);
|
|
|
|
edit.remove("rssfeed_lastvieweditemurl_" + max);
|
|
|
|
edit.apply();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers for some RSS feed (as identified by its order numbe/key) the last date and time that it was viewed by
|
|
|
|
* the user. This is used to determine which items in an RSS feed are 'new'. Warning: any previously retrieved
|
|
|
|
* {@link RssfeedSetting} object is now no longer in sync, as this will not automatically be updated in the object.
|
|
|
|
* Use {@link #getRssfeedSetting(int)} to get fresh data.
|
|
|
|
*
|
|
|
|
* @param order The identifying order number/key of the settings of te RSS feed that was viewed
|
|
|
|
* @param lastViewed The date and time that the feed was last viewed; typically now
|
|
|
|
* @param lastViewedItemUrl The url of the last item the last time that the feed was viewed
|
|
|
|
*/
|
|
|
|
public void setRssfeedLastViewer(int order, Date lastViewed, String lastViewedItemUrl) {
|
|
|
|
if (prefs.getString("rssfeed_url_" + order, null) == null)
|
|
|
|
return; // The settings that were requested to be removed do not exist
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
edit.putLong("rssfeed_lastviewed_" + order, lastViewed.getTime());
|
|
|
|
edit.putString("rssfeed_lastvieweditemurl_" + order, lastViewedItemUrl);
|
|
|
|
edit.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers the torrents list sort order as being last used by the user
|
|
|
|
*
|
|
|
|
* @param currentSortOrder The sort order property the user selected last
|
|
|
|
* @param currentSortAscending The sort order direction that was last used
|
|
|
|
*/
|
|
|
|
public void setLastUsedSortOrder(TorrentsSortBy currentSortOrder, boolean currentSortAscending) {
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
edit.putInt("system_lastusedsortorder", currentSortOrder.getCode());
|
|
|
|
edit.putBoolean("system_lastusedsortdirection", currentSortAscending);
|
|
|
|
edit.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the sort order property that the user last used. Use together with {@link #getLastUsedSortDescending()}
|
|
|
|
* to get the full last used sort settings.
|
|
|
|
*
|
|
|
|
* @return The last used sort order enumeration value
|
|
|
|
*/
|
|
|
|
public TorrentsSortBy getLastUsedSortOrder() {
|
|
|
|
return TorrentsSortBy
|
|
|
|
.getStatus(prefs.getInt("system_lastusedsortorder", TorrentsSortBy.Alphanumeric.getCode()));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers the search list sort order as being last used by the user
|
|
|
|
*
|
|
|
|
* @param currentSortOrder The sort order property the user selected last
|
|
|
|
*/
|
|
|
|
public void setLastUsedSearchSortOrder(SearchSortOrder currentSortOrder) {
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
edit.putInt("system_lastusedsearchsortorder", currentSortOrder.ordinal());
|
|
|
|
edit.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the search sort order property that the user last used.
|
|
|
|
*
|
|
|
|
* @return The last used sort order enumeration value
|
|
|
|
*/
|
|
|
|
public SearchSortOrder getLastUsedSearchSortOrder() {
|
|
|
|
return SearchSortOrder.values()[(prefs.getInt("system_lastusedsearchsortorder", SearchSortOrder.BySeeders.ordinal()))];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the sort order direction that the user last used. Use together with {@link #getLastUsedSortOrder()} to
|
|
|
|
* get the full last used sort settings.
|
|
|
|
*
|
|
|
|
* @return True if the last used sort direction was descending, false otherwise (i.e. the default ascending
|
|
|
|
* direction)
|
|
|
|
*/
|
|
|
|
public boolean getLastUsedSortDescending() {
|
|
|
|
return prefs.getBoolean("system_lastusedsortdirection", false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the list of all available in-app search sites as well as all web searches that the user configured.
|
|
|
|
*
|
|
|
|
* @return A list of search settings, all of which are either a {@link SearchSite} or {@link WebsearchSetting}
|
|
|
|
*/
|
|
|
|
public List<SearchSetting> getSearchSettings() {
|
|
|
|
List<SearchSetting> all = new ArrayList<>();
|
|
|
|
all.addAll(searchHelper.getAvailableSites());
|
|
|
|
all.addAll(getWebsearchSettings());
|
|
|
|
return Collections.unmodifiableList(all);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the settings of the search site that was last used by the user or was selected by the user as default
|
|
|
|
* site in the main settings. As opposed to getLastUsedSearchSiteKey(int), this method checks whether a site was
|
|
|
|
* already registered as being last used (or set as default) and checks whether the site still exists. It returns
|
|
|
|
* the first in-app search site if that fails.
|
|
|
|
*
|
|
|
|
* @return A site settings object of the last used server (or, if not known, the first server), or null if no
|
|
|
|
* servers exist
|
|
|
|
*/
|
|
|
|
public SearchSetting getLastUsedSearchSite() {
|
|
|
|
String lastKey = getLastUsedSearchSiteKey();
|
|
|
|
List<SearchSite> allsites = searchHelper.getAvailableSites();
|
|
|
|
|
|
|
|
if (lastKey == null) {
|
|
|
|
// No site yet set specified; return the first in-app one, if available
|
|
|
|
if (allsites != null) {
|
|
|
|
return allsites.get(0);
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
int lastWebsearch = -1;
|
|
|
|
if (lastKey.startsWith(WebsearchSetting.KEY_PREFIX)) {
|
|
|
|
try {
|
|
|
|
lastWebsearch = Integer.parseInt(lastKey.substring(WebsearchSetting.KEY_PREFIX.length()));
|
|
|
|
} catch (Exception e) {
|
|
|
|
// Not an in-app search site, but probably an in-app search
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (lastWebsearch >= 0) {
|
|
|
|
// The last used site should be a user-configured web search site
|
|
|
|
int max = getMaxWebsearch(); // Zero-based index, so with max == 0 there is 1 server
|
|
|
|
if (max < 0 || lastWebsearch > max) {
|
|
|
|
// No web search sites configured
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return getWebsearchSetting(lastWebsearch);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Should be an in-app search key
|
|
|
|
if (allsites != null && !allsites.isEmpty()) {
|
|
|
|
for (SearchSite searchSite : allsites) {
|
|
|
|
if (searchSite.getKey().equals(lastKey)) {
|
|
|
|
return searchSite;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Not found at all; probably a no longer existing web search; return the first in-app one
|
|
|
|
return allsites.get(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the unique key of the site that the used last used or selected as default form the main settings; use
|
|
|
|
* with getLastUsedSearchSite directly. WARNING: the returned string may no longer refer to a known web search site
|
|
|
|
* or in-app search settings object.
|
|
|
|
*
|
|
|
|
* @return A string indicating the key of the last used search site, or null if no site was yet used or set as
|
|
|
|
* default
|
|
|
|
*/
|
|
|
|
private String getLastUsedSearchSiteKey() {
|
|
|
|
return prefs.getString("header_setsearchsite", null);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers the unique key of some web search or in-app search site as being last used by the user
|
|
|
|
*
|
|
|
|
* @param site The site settings to register as being last used
|
|
|
|
*/
|
|
|
|
public void setLastUsedSearchSite(SearchSetting site) {
|
|
|
|
prefs.edit().putString("header_setsearchsite", site.getKey()).apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the statistics of this server as it was last seen by the background server checker service.
|
|
|
|
*
|
|
|
|
* @param server The server for which to retrieved the statistics from the stored preferences
|
|
|
|
* @return A JSON array of JSON objects, each which represent a since torrent
|
|
|
|
*/
|
|
|
|
public JSONArray getServerLastStats(ServerSetting server) {
|
|
|
|
String lastStats = prefs.getString(server.getUniqueIdentifier(), null);
|
|
|
|
if (lastStats == null)
|
|
|
|
return null;
|
|
|
|
try {
|
|
|
|
return new JSONArray(lastStats);
|
|
|
|
} catch (JSONException e) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stores the now-last seen statistics of the supplied server by the background server checker service to the
|
|
|
|
* internal stored preferences.
|
|
|
|
*
|
|
|
|
* @param server The server to which the statistics apply to
|
|
|
|
* @param lastStats A JSON array of JSON objects that each represent a single seen torrent
|
|
|
|
*/
|
|
|
|
public void setServerLastStats(ServerSetting server, JSONArray lastStats) {
|
|
|
|
prefs.edit().putString(server.getUniqueIdentifier(), lastStats.toString()).apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the user configuration for some specific app widget, if the widget is known at all.
|
|
|
|
*
|
|
|
|
* @param appWidgetId The unique ID of the app widget to retrieve settings for, as supplied by the AppWidgetManager
|
|
|
|
* @return A widget configuration object, or null if no settings were stored for the widget ID
|
|
|
|
*/
|
|
|
|
public ListWidgetConfig getWidgetConfig(int appWidgetId) {
|
|
|
|
if (!prefs.contains("widget_server_" + appWidgetId))
|
|
|
|
return null;
|
|
|
|
// @formatter:off
|
|
|
|
return new ListWidgetConfig(
|
|
|
|
prefs.getInt("widget_server_" + appWidgetId, -1),
|
|
|
|
StatusType.valueOf(prefs.getString("widget_status_" + appWidgetId, StatusType.ShowAll.name())),
|
|
|
|
TorrentsSortBy.valueOf(prefs.getString("widget_sortby_" + appWidgetId, TorrentsSortBy.Alphanumeric.name())),
|
|
|
|
prefs.getBoolean("widget_reverse_" + appWidgetId, false),
|
|
|
|
prefs.getBoolean("widget_showstatus_" + appWidgetId, false));
|
|
|
|
// @formatter:on
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stores the user settings for some specific app widget. Existing settings for the supplied app widget ID will be
|
|
|
|
* overridden.
|
|
|
|
*
|
|
|
|
* @param appWidgetId The unique ID of the app widget to store settings for, as supplied by the AppWidgetManager
|
|
|
|
* @param settings A widget configuration object, which may not be null
|
|
|
|
*/
|
|
|
|
public void setWidgetConfig(int appWidgetId, ListWidgetConfig settings) {
|
|
|
|
if (settings == null)
|
|
|
|
throw new InvalidParameterException(
|
|
|
|
"The widget setting may not be null. Use removeWidgetConfig instead to remove existing settings for some app widget.");
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
edit.putInt("widget_server_" + appWidgetId, settings.getServerId());
|
|
|
|
edit.putString("widget_status_" + appWidgetId, settings.getStatusType().name());
|
|
|
|
edit.putString("widget_sortby_" + appWidgetId, settings.getSortBy().name());
|
|
|
|
edit.putBoolean("widget_reverse_" + appWidgetId, settings.shouldReserveSort());
|
|
|
|
edit.putBoolean("widget_showstatus_" + appWidgetId, settings.shouldShowStatusView());
|
|
|
|
edit.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Remove the setting for some specific app widget.
|
|
|
|
*
|
|
|
|
* @param appWidgetId The unique ID of the app widget to store settings for, as supplied by the AppWidgetManager
|
|
|
|
*/
|
|
|
|
public void removeWidgetConfig(int appWidgetId) {
|
|
|
|
Editor edit = prefs.edit();
|
|
|
|
edit.remove("widget_server_" + appWidgetId);
|
|
|
|
edit.remove("widget_status_" + appWidgetId);
|
|
|
|
edit.remove("widget_sortby_" + appWidgetId);
|
|
|
|
edit.remove("widget_reverse_" + appWidgetId);
|
|
|
|
edit.remove("widget_showstatus_" + appWidgetId);
|
|
|
|
edit.remove("widget_darktheme_" + appWidgetId);
|
|
|
|
edit.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Trims away whitespace around a string, or returns null if str is null
|
|
|
|
*
|
|
|
|
* @param str The string to trim, or null
|
|
|
|
* @return The trimmed string, or null if str is null
|
|
|
|
*/
|
|
|
|
private String trim(String str) {
|
|
|
|
if (str == null) return null;
|
|
|
|
return str.trim();
|
|
|
|
}
|
|
|
|
|
|
|
|
private int parseInt(String string, int defaultValue) {
|
|
|
|
try {
|
|
|
|
return Integer.parseInt(string);
|
|
|
|
} catch (NumberFormatException e) {
|
|
|
|
return defaultValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|