743 lines
32 KiB
Java
743 lines
32 KiB
Java
/*
|
|
This file is part of Subsonic.
|
|
Subsonic 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.
|
|
Subsonic 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 Subsonic. If not, see <http://www.gnu.org/licenses/>.
|
|
Copyright 2014 (C) Scott Jackson
|
|
*/
|
|
|
|
package net.nullsum.audinaut.fragments;
|
|
|
|
import android.accounts.Account;
|
|
import android.app.backup.BackupManager;
|
|
import android.content.ContentResolver;
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.preference.CheckBoxPreference;
|
|
import android.preference.EditTextPreference;
|
|
import android.preference.ListPreference;
|
|
import android.preference.Preference;
|
|
import android.preference.PreferenceCategory;
|
|
import android.preference.PreferenceScreen;
|
|
import android.text.InputType;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.Button;
|
|
import android.widget.EditText;
|
|
|
|
import net.nullsum.audinaut.R;
|
|
import net.nullsum.audinaut.service.DownloadService;
|
|
import net.nullsum.audinaut.service.HeadphoneListenerService;
|
|
import net.nullsum.audinaut.service.MusicService;
|
|
import net.nullsum.audinaut.service.MusicServiceFactory;
|
|
import net.nullsum.audinaut.util.Constants;
|
|
import net.nullsum.audinaut.util.FileUtil;
|
|
import net.nullsum.audinaut.util.LoadingTask;
|
|
import net.nullsum.audinaut.util.SyncUtil;
|
|
import net.nullsum.audinaut.util.Util;
|
|
import net.nullsum.audinaut.view.CacheLocationPreference;
|
|
import net.nullsum.audinaut.view.ErrorDialog;
|
|
|
|
import java.io.File;
|
|
import java.net.URL;
|
|
import java.text.DecimalFormat;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
|
|
public class SettingsFragment extends PreferenceCompatFragment implements SharedPreferences.OnSharedPreferenceChangeListener {
|
|
private final static String TAG = SettingsFragment.class.getSimpleName();
|
|
|
|
private final Map<String, ServerSettings> serverSettings = new LinkedHashMap<>();
|
|
private boolean testingConnection;
|
|
private ListPreference theme;
|
|
private ListPreference maxBitrateWifi;
|
|
private ListPreference maxBitrateMobile;
|
|
private ListPreference networkTimeout;
|
|
private CacheLocationPreference cacheLocation;
|
|
private ListPreference preloadCountWifi;
|
|
private ListPreference preloadCountMobile;
|
|
private ListPreference keepPlayedCount;
|
|
private ListPreference tempLoss;
|
|
private ListPreference pauseDisconnect;
|
|
private PreferenceCategory serversCategory;
|
|
private ListPreference songPressAction;
|
|
private ListPreference syncInterval;
|
|
private CheckBoxPreference syncEnabled;
|
|
private CheckBoxPreference syncWifi;
|
|
private CheckBoxPreference syncNotification;
|
|
private CheckBoxPreference syncMostRecent;
|
|
private CheckBoxPreference replayGain;
|
|
private ListPreference replayGainType;
|
|
private Preference replayGainBump;
|
|
private Preference replayGainUntagged;
|
|
private String internalSSID;
|
|
private String internalSSIDDisplay;
|
|
private EditTextPreference cacheSize;
|
|
|
|
private int serverCount = 3;
|
|
private SharedPreferences settings;
|
|
private DecimalFormat megabyteFromat;
|
|
|
|
@Override
|
|
public void onCreate(Bundle bundle) {
|
|
super.onCreate(bundle);
|
|
|
|
int instance = this.getArguments().getInt(Constants.PREFERENCES_KEY_SERVER_INSTANCE, -1);
|
|
if (instance != -1) {
|
|
PreferenceScreen preferenceScreen = expandServer(instance);
|
|
setPreferenceScreen(preferenceScreen);
|
|
|
|
serverSettings.put(Integer.toString(instance), new ServerSettings(instance));
|
|
onInitPreferences(preferenceScreen);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
super.onDestroy();
|
|
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
prefs.unregisterOnSharedPreferenceChangeListener(this);
|
|
}
|
|
|
|
@Override
|
|
protected void onStartNewFragment(String name) {
|
|
SettingsFragment newFragment = new SettingsFragment();
|
|
Bundle args = new Bundle();
|
|
|
|
int xml = 0;
|
|
if ("appearance".equals(name)) {
|
|
xml = R.xml.settings_appearance;
|
|
} else if ("cache".equals(name)) {
|
|
xml = R.xml.settings_cache;
|
|
} else if ("playback".equals(name)) {
|
|
xml = R.xml.settings_playback;
|
|
} else if ("servers".equals(name)) {
|
|
xml = R.xml.settings_servers;
|
|
}
|
|
|
|
if (xml != 0) {
|
|
args.putInt(Constants.INTENT_EXTRA_FRAGMENT_TYPE, xml);
|
|
newFragment.setArguments(args);
|
|
replaceFragment(newFragment);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
|
|
// Random error I have no idea how to reproduce
|
|
if (sharedPreferences == null) {
|
|
return;
|
|
}
|
|
|
|
update();
|
|
|
|
if (Constants.PREFERENCES_KEY_HIDE_MEDIA.equals(key)) {
|
|
setHideMedia(sharedPreferences.getBoolean(key, true));
|
|
} else if (Constants.PREFERENCES_KEY_MEDIA_BUTTONS.equals(key)) {
|
|
setMediaButtonsEnabled(sharedPreferences.getBoolean(key, true));
|
|
} else if (Constants.PREFERENCES_KEY_CACHE_LOCATION.equals(key)) {
|
|
setCacheLocation(sharedPreferences.getString(key, ""));
|
|
} else if (Constants.PREFERENCES_KEY_SYNC_MOST_RECENT.equals(key)) {
|
|
SyncUtil.removeMostRecentSyncFiles(context);
|
|
} else if (Constants.PREFERENCES_KEY_REPLAY_GAIN.equals(key) || Constants.PREFERENCES_KEY_REPLAY_GAIN_BUMP.equals(key) || Constants.PREFERENCES_KEY_REPLAY_GAIN_UNTAGGED.equals(key)) {
|
|
DownloadService downloadService = DownloadService.getInstance();
|
|
if (downloadService != null) {
|
|
downloadService.reapplyVolume();
|
|
}
|
|
} else if (Constants.PREFERENCES_KEY_START_ON_HEADPHONES.equals(key)) {
|
|
Intent serviceIntent = new Intent();
|
|
serviceIntent.setClassName(context.getPackageName(), HeadphoneListenerService.class.getName());
|
|
|
|
if (sharedPreferences.getBoolean(key, false)) {
|
|
context.startService(serviceIntent);
|
|
} else {
|
|
context.stopService(serviceIntent);
|
|
}
|
|
}
|
|
|
|
scheduleBackup();
|
|
}
|
|
|
|
@Override
|
|
protected void onInitPreferences(PreferenceScreen preferenceScreen) {
|
|
this.setTitle(preferenceScreen.getTitle());
|
|
|
|
internalSSID = Util.getSSID(context);
|
|
if (internalSSID == null) {
|
|
internalSSID = "";
|
|
}
|
|
internalSSIDDisplay = context.getResources().getString(R.string.settings_server_local_network_ssid_hint, internalSSID);
|
|
|
|
theme = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_THEME);
|
|
maxBitrateWifi = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_MAX_BITRATE_WIFI);
|
|
maxBitrateMobile = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_MAX_BITRATE_MOBILE);
|
|
networkTimeout = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_NETWORK_TIMEOUT);
|
|
cacheLocation = (CacheLocationPreference) this.findPreference(Constants.PREFERENCES_KEY_CACHE_LOCATION);
|
|
preloadCountWifi = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_PRELOAD_COUNT_WIFI);
|
|
preloadCountMobile = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_PRELOAD_COUNT_MOBILE);
|
|
keepPlayedCount = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_KEEP_PLAYED_CNT);
|
|
tempLoss = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_TEMP_LOSS);
|
|
pauseDisconnect = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_PAUSE_DISCONNECT);
|
|
serversCategory = (PreferenceCategory) this.findPreference(Constants.PREFERENCES_KEY_SERVER_KEY);
|
|
Preference addServerPreference = this.findPreference(Constants.PREFERENCES_KEY_SERVER_ADD);
|
|
songPressAction = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_SONG_PRESS_ACTION);
|
|
syncInterval = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_SYNC_INTERVAL);
|
|
syncEnabled = (CheckBoxPreference) this.findPreference(Constants.PREFERENCES_KEY_SYNC_ENABLED);
|
|
syncWifi = (CheckBoxPreference) this.findPreference(Constants.PREFERENCES_KEY_SYNC_WIFI);
|
|
syncNotification = (CheckBoxPreference) this.findPreference(Constants.PREFERENCES_KEY_SYNC_NOTIFICATION);
|
|
syncMostRecent = (CheckBoxPreference) this.findPreference(Constants.PREFERENCES_KEY_SYNC_MOST_RECENT);
|
|
replayGain = (CheckBoxPreference) this.findPreference(Constants.PREFERENCES_KEY_REPLAY_GAIN);
|
|
replayGainType = (ListPreference) this.findPreference(Constants.PREFERENCES_KEY_REPLAY_GAIN_TYPE);
|
|
replayGainBump = this.findPreference(Constants.PREFERENCES_KEY_REPLAY_GAIN_BUMP);
|
|
replayGainUntagged = this.findPreference(Constants.PREFERENCES_KEY_REPLAY_GAIN_UNTAGGED);
|
|
cacheSize = (EditTextPreference) this.findPreference(Constants.PREFERENCES_KEY_CACHE_SIZE);
|
|
|
|
settings = Util.getPreferences(context);
|
|
serverCount = settings.getInt(Constants.PREFERENCES_KEY_SERVER_COUNT, 1);
|
|
|
|
if (cacheSize != null) {
|
|
this.findPreference("clearCache").setOnPreferenceClickListener(preference -> {
|
|
Util.confirmDialog(context, (dialog, which) -> new LoadingTask<Void>(context, false) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
FileUtil.deleteMusicDirectory(context);
|
|
FileUtil.deleteSerializedCache(context);
|
|
FileUtil.deleteArtworkCache(context);
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void done(Void result) {
|
|
Util.toast(context, R.string.settings_cache_clear_complete);
|
|
}
|
|
|
|
@Override
|
|
protected void error(Throwable error) {
|
|
Util.toast(context, getErrorMessage(error), false);
|
|
}
|
|
}.execute());
|
|
return false;
|
|
});
|
|
}
|
|
|
|
if (syncEnabled != null) {
|
|
this.findPreference(Constants.PREFERENCES_KEY_SYNC_ENABLED).setOnPreferenceChangeListener((preference, newValue) -> {
|
|
Boolean syncEnabled = (Boolean) newValue;
|
|
|
|
Account account = new Account(Constants.SYNC_ACCOUNT_NAME, Constants.SYNC_ACCOUNT_TYPE);
|
|
ContentResolver.setSyncAutomatically(account, Constants.SYNC_ACCOUNT_PLAYLIST_AUTHORITY, syncEnabled);
|
|
|
|
return true;
|
|
});
|
|
syncInterval.setOnPreferenceChangeListener((preference, newValue) -> {
|
|
Integer syncInterval = Integer.parseInt(((String) newValue));
|
|
|
|
Account account = new Account(Constants.SYNC_ACCOUNT_NAME, Constants.SYNC_ACCOUNT_TYPE);
|
|
ContentResolver.addPeriodicSync(account, Constants.SYNC_ACCOUNT_PLAYLIST_AUTHORITY, new Bundle(), 60L * syncInterval);
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
if (serversCategory != null) {
|
|
addServerPreference.setOnPreferenceClickListener(preference -> {
|
|
serverCount++;
|
|
int instance = serverCount;
|
|
serversCategory.addPreference(addServer(serverCount));
|
|
|
|
SharedPreferences.Editor editor = settings.edit();
|
|
editor.putInt(Constants.PREFERENCES_KEY_SERVER_COUNT, serverCount);
|
|
// Reset set folder ID
|
|
editor.putString(Constants.PREFERENCES_KEY_MUSIC_FOLDER_ID + instance, null);
|
|
editor.putString(Constants.PREFERENCES_KEY_SERVER_URL + instance, "http://yourhost");
|
|
editor.putString(Constants.PREFERENCES_KEY_SERVER_NAME + instance, getResources().getString(R.string.settings_server_unused));
|
|
editor.apply();
|
|
|
|
ServerSettings ss = new ServerSettings(instance);
|
|
serverSettings.put(String.valueOf(instance), ss);
|
|
ss.update();
|
|
|
|
return true;
|
|
});
|
|
|
|
serversCategory.setOrderingAsAdded(false);
|
|
for (int i = 1; i <= serverCount; i++) {
|
|
serversCategory.addPreference(addServer(i));
|
|
serverSettings.put(String.valueOf(i), new ServerSettings(i));
|
|
}
|
|
}
|
|
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
prefs.registerOnSharedPreferenceChangeListener(this);
|
|
|
|
update();
|
|
}
|
|
|
|
private void scheduleBackup() {
|
|
BackupManager backupManager = new BackupManager(context);
|
|
backupManager.dataChanged();
|
|
}
|
|
|
|
private void update() {
|
|
if (testingConnection) {
|
|
return;
|
|
}
|
|
|
|
if (theme != null) {
|
|
theme.setSummary(theme.getEntry());
|
|
}
|
|
|
|
if (cacheSize != null) {
|
|
maxBitrateWifi.setSummary(maxBitrateWifi.getEntry());
|
|
maxBitrateMobile.setSummary(maxBitrateMobile.getEntry());
|
|
networkTimeout.setSummary(networkTimeout.getEntry());
|
|
cacheLocation.setSummary(cacheLocation.getText());
|
|
preloadCountWifi.setSummary(preloadCountWifi.getEntry());
|
|
preloadCountMobile.setSummary(preloadCountMobile.getEntry());
|
|
|
|
try {
|
|
if (megabyteFromat == null) {
|
|
megabyteFromat = new DecimalFormat(getResources().getString(R.string.util_bytes_format_megabyte));
|
|
}
|
|
|
|
cacheSize.setSummary(megabyteFromat.format((double) Integer.parseInt(cacheSize.getText())).replace(".00", ""));
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Failed to format cache size", e);
|
|
cacheSize.setSummary(cacheSize.getText());
|
|
}
|
|
}
|
|
|
|
if (keepPlayedCount != null) {
|
|
keepPlayedCount.setSummary(keepPlayedCount.getEntry());
|
|
tempLoss.setSummary(tempLoss.getEntry());
|
|
pauseDisconnect.setSummary(pauseDisconnect.getEntry());
|
|
songPressAction.setSummary(songPressAction.getEntry());
|
|
|
|
if (replayGain.isChecked()) {
|
|
replayGainType.setEnabled(true);
|
|
replayGainBump.setEnabled(true);
|
|
replayGainUntagged.setEnabled(true);
|
|
} else {
|
|
replayGainType.setEnabled(false);
|
|
replayGainBump.setEnabled(false);
|
|
replayGainUntagged.setEnabled(false);
|
|
}
|
|
replayGainType.setSummary(replayGainType.getEntry());
|
|
}
|
|
|
|
if (syncEnabled != null) {
|
|
syncInterval.setSummary(syncInterval.getEntry());
|
|
|
|
if (syncEnabled.isChecked()) {
|
|
if (!syncInterval.isEnabled()) {
|
|
syncInterval.setEnabled(true);
|
|
syncWifi.setEnabled(true);
|
|
syncNotification.setEnabled(true);
|
|
syncMostRecent.setEnabled(true);
|
|
}
|
|
} else {
|
|
if (syncInterval.isEnabled()) {
|
|
syncInterval.setEnabled(false);
|
|
syncWifi.setEnabled(false);
|
|
syncNotification.setEnabled(false);
|
|
syncMostRecent.setEnabled(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (ServerSettings ss : serverSettings.values()) {
|
|
ss.update();
|
|
}
|
|
}
|
|
|
|
private void checkForRemoved() {
|
|
for (ServerSettings ss : serverSettings.values()) {
|
|
if (!ss.update()) {
|
|
serversCategory.removePreference(ss.getScreen());
|
|
serverCount--;
|
|
}
|
|
}
|
|
}
|
|
|
|
private PreferenceScreen addServer(final int instance) {
|
|
final PreferenceScreen screen = this.getPreferenceManager().createPreferenceScreen(context);
|
|
screen.setKey(Constants.PREFERENCES_KEY_SERVER_KEY + instance);
|
|
screen.setOrder(instance);
|
|
|
|
screen.setOnPreferenceClickListener(preference -> {
|
|
SettingsFragment newFragment = new SettingsFragment();
|
|
|
|
Bundle args = new Bundle();
|
|
args.putInt(Constants.PREFERENCES_KEY_SERVER_INSTANCE, instance);
|
|
newFragment.setArguments(args);
|
|
|
|
replaceFragment(newFragment);
|
|
return false;
|
|
});
|
|
|
|
return screen;
|
|
}
|
|
|
|
private PreferenceScreen expandServer(final int instance) {
|
|
final PreferenceScreen screen = this.getPreferenceManager().createPreferenceScreen(context);
|
|
screen.setTitle(R.string.settings_server_unused);
|
|
screen.setKey(Constants.PREFERENCES_KEY_SERVER_KEY + instance);
|
|
|
|
final EditTextPreference serverNamePreference = new EditTextPreference(context);
|
|
serverNamePreference.setKey(Constants.PREFERENCES_KEY_SERVER_NAME + instance);
|
|
serverNamePreference.setDefaultValue(getResources().getString(R.string.settings_server_unused));
|
|
serverNamePreference.setTitle(R.string.settings_server_name);
|
|
serverNamePreference.setDialogTitle(R.string.settings_server_name);
|
|
|
|
if (serverNamePreference.getText() == null) {
|
|
serverNamePreference.setText(getResources().getString(R.string.settings_server_unused));
|
|
}
|
|
|
|
serverNamePreference.setSummary(serverNamePreference.getText());
|
|
|
|
final EditTextPreference serverUrlPreference = new EditTextPreference(context);
|
|
serverUrlPreference.setKey(Constants.PREFERENCES_KEY_SERVER_URL + instance);
|
|
serverUrlPreference.getEditText().setInputType(InputType.TYPE_TEXT_VARIATION_URI);
|
|
serverUrlPreference.setDefaultValue("http://yourhost");
|
|
serverUrlPreference.setTitle(R.string.settings_server_address);
|
|
serverUrlPreference.setDialogTitle(R.string.settings_server_address);
|
|
|
|
if (serverUrlPreference.getText() == null) {
|
|
serverUrlPreference.setText("http://yourhost");
|
|
}
|
|
|
|
serverUrlPreference.setSummary(serverUrlPreference.getText());
|
|
screen.setSummary(serverUrlPreference.getText());
|
|
|
|
final EditTextPreference serverLocalNetworkSSIDPreference = new EditTextPreference(context) {
|
|
@Override
|
|
protected void onAddEditTextToDialogView(View dialogView, final EditText editText) {
|
|
super.onAddEditTextToDialogView(dialogView, editText);
|
|
ViewGroup root = (ViewGroup) ((ViewGroup) dialogView).getChildAt(0);
|
|
|
|
Button defaultButton = new Button(getContext());
|
|
defaultButton.setText(internalSSIDDisplay);
|
|
defaultButton.setOnClickListener(v -> editText.setText(internalSSID));
|
|
root.addView(defaultButton);
|
|
}
|
|
};
|
|
serverLocalNetworkSSIDPreference.setKey(Constants.PREFERENCES_KEY_SERVER_LOCAL_NETWORK_SSID + instance);
|
|
serverLocalNetworkSSIDPreference.setTitle(R.string.settings_server_local_network_ssid);
|
|
serverLocalNetworkSSIDPreference.setDialogTitle(R.string.settings_server_local_network_ssid);
|
|
|
|
final EditTextPreference serverInternalUrlPreference = new EditTextPreference(context);
|
|
serverInternalUrlPreference.setKey(Constants.PREFERENCES_KEY_SERVER_INTERNAL_URL + instance);
|
|
serverInternalUrlPreference.getEditText().setInputType(InputType.TYPE_TEXT_VARIATION_URI);
|
|
serverInternalUrlPreference.setDefaultValue("");
|
|
serverInternalUrlPreference.setTitle(R.string.settings_server_internal_address);
|
|
serverInternalUrlPreference.setDialogTitle(R.string.settings_server_internal_address);
|
|
serverInternalUrlPreference.setSummary(serverInternalUrlPreference.getText());
|
|
|
|
final EditTextPreference serverUsernamePreference = new EditTextPreference(context);
|
|
serverUsernamePreference.setKey(Constants.PREFERENCES_KEY_USERNAME + instance);
|
|
serverUsernamePreference.setTitle(R.string.settings_server_username);
|
|
serverUsernamePreference.setDialogTitle(R.string.settings_server_username);
|
|
|
|
final EditTextPreference serverPasswordPreference = new EditTextPreference(context);
|
|
serverPasswordPreference.setKey(Constants.PREFERENCES_KEY_PASSWORD + instance);
|
|
serverPasswordPreference.getEditText().setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
|
|
serverPasswordPreference.setSummary("***");
|
|
serverPasswordPreference.setTitle(R.string.settings_server_password);
|
|
|
|
final Preference serverOpenBrowser = new Preference(context);
|
|
serverOpenBrowser.setKey(Constants.PREFERENCES_KEY_OPEN_BROWSER);
|
|
serverOpenBrowser.setPersistent(false);
|
|
serverOpenBrowser.setTitle(R.string.settings_server_open_browser);
|
|
serverOpenBrowser.setOnPreferenceClickListener(preference -> {
|
|
openInBrowser(instance);
|
|
return true;
|
|
});
|
|
|
|
Preference serverRemoveServerPreference = new Preference(context);
|
|
serverRemoveServerPreference.setKey(Constants.PREFERENCES_KEY_SERVER_REMOVE + instance);
|
|
serverRemoveServerPreference.setPersistent(false);
|
|
serverRemoveServerPreference.setTitle(R.string.settings_servers_remove);
|
|
|
|
serverRemoveServerPreference.setOnPreferenceClickListener(preference -> {
|
|
Util.confirmDialog(context, R.string.common_delete, screen.getTitle().toString(), (dialog, which) -> {
|
|
// Reset values to null so when we ask for them again they are new
|
|
serverNamePreference.setText(null);
|
|
serverUrlPreference.setText(null);
|
|
serverUsernamePreference.setText(null);
|
|
serverPasswordPreference.setText(null);
|
|
|
|
// Don't use Util.getActiveServer since it is 0 if offline
|
|
int activeServer = Util.getPreferences(context).getInt(Constants.PREFERENCES_KEY_SERVER_INSTANCE, 1);
|
|
for (int i = instance; i <= serverCount; i++) {
|
|
Util.removeInstanceName(context, i, activeServer);
|
|
}
|
|
|
|
serverCount--;
|
|
SharedPreferences.Editor editor = settings.edit();
|
|
editor.putInt(Constants.PREFERENCES_KEY_SERVER_COUNT, serverCount);
|
|
editor.apply();
|
|
|
|
removeCurrent();
|
|
|
|
SubsonicFragment parentFragment = context.getCurrentFragment();
|
|
if (parentFragment instanceof SettingsFragment) {
|
|
SettingsFragment serverSelectionFragment = (SettingsFragment) parentFragment;
|
|
serverSelectionFragment.checkForRemoved();
|
|
}
|
|
});
|
|
|
|
return true;
|
|
});
|
|
|
|
Preference serverTestConnectionPreference = new Preference(context);
|
|
serverTestConnectionPreference.setKey(Constants.PREFERENCES_KEY_TEST_CONNECTION + instance);
|
|
serverTestConnectionPreference.setPersistent(false);
|
|
serverTestConnectionPreference.setTitle(R.string.settings_test_connection_title);
|
|
serverTestConnectionPreference.setOnPreferenceClickListener(preference -> {
|
|
testConnection(instance);
|
|
return false;
|
|
});
|
|
|
|
screen.addPreference(serverNamePreference);
|
|
screen.addPreference(serverUrlPreference);
|
|
screen.addPreference(serverInternalUrlPreference);
|
|
screen.addPreference(serverLocalNetworkSSIDPreference);
|
|
screen.addPreference(serverUsernamePreference);
|
|
screen.addPreference(serverPasswordPreference);
|
|
screen.addPreference(serverTestConnectionPreference);
|
|
screen.addPreference(serverOpenBrowser);
|
|
screen.addPreference(serverRemoveServerPreference);
|
|
|
|
return screen;
|
|
}
|
|
|
|
private void setHideMedia(boolean hide) {
|
|
File nomediaDir = new File(FileUtil.getSubsonicDirectory(context), ".nomedia");
|
|
File musicNoMedia = new File(FileUtil.getMusicDirectory(context), ".nomedia");
|
|
if (hide && !nomediaDir.exists()) {
|
|
try {
|
|
if (!nomediaDir.createNewFile()) {
|
|
Log.w(TAG, "Failed to create " + nomediaDir);
|
|
}
|
|
} catch (Exception e) {
|
|
Log.w(TAG, "Failed to create " + nomediaDir, e);
|
|
}
|
|
|
|
try {
|
|
if (!musicNoMedia.createNewFile()) {
|
|
Log.w(TAG, "Failed to create " + musicNoMedia);
|
|
}
|
|
} catch (Exception e) {
|
|
Log.w(TAG, "Failed to create " + musicNoMedia, e);
|
|
}
|
|
} else if (!hide && nomediaDir.exists()) {
|
|
if (!nomediaDir.delete()) {
|
|
Log.w(TAG, "Failed to delete " + nomediaDir);
|
|
}
|
|
if (!musicNoMedia.delete()) {
|
|
Log.w(TAG, "Failed to delete " + musicNoMedia);
|
|
}
|
|
}
|
|
Util.toast(context, R.string.settings_hide_media_toast, false);
|
|
}
|
|
|
|
private void setMediaButtonsEnabled(boolean enabled) {
|
|
if (enabled) {
|
|
Util.registerMediaButtonEventReceiver(context);
|
|
} else {
|
|
Util.unregisterMediaButtonEventReceiver(context);
|
|
}
|
|
}
|
|
|
|
private void setCacheLocation(String path) {
|
|
File dir = new File(path);
|
|
if (!FileUtil.verifyCanWrite(dir)) {
|
|
Util.toast(context, R.string.settings_cache_location_error, false);
|
|
|
|
// Reset it to the default.
|
|
String defaultPath = FileUtil.getDefaultMusicDirectory(context).getPath();
|
|
if (!defaultPath.equals(path)) {
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
SharedPreferences.Editor editor = prefs.edit();
|
|
editor.putString(Constants.PREFERENCES_KEY_CACHE_LOCATION, defaultPath);
|
|
editor.apply();
|
|
|
|
if (cacheLocation != null) {
|
|
cacheLocation.setSummary(defaultPath);
|
|
cacheLocation.setText(defaultPath);
|
|
}
|
|
}
|
|
|
|
// Clear download queue.
|
|
DownloadService downloadService = DownloadService.getInstance();
|
|
downloadService.clear();
|
|
}
|
|
}
|
|
|
|
private void testConnection(final int instance) {
|
|
LoadingTask<Boolean> task = new LoadingTask<Boolean>(context) {
|
|
private int previousInstance;
|
|
|
|
@Override
|
|
protected Boolean doInBackground() throws Throwable {
|
|
updateProgress();
|
|
|
|
previousInstance = Util.getActiveServer(context);
|
|
testingConnection = true;
|
|
MusicService musicService = MusicServiceFactory.getOnlineService();
|
|
try {
|
|
musicService.setInstance(instance);
|
|
musicService.ping(context, this);
|
|
return true;
|
|
} finally {
|
|
musicService.setInstance(null);
|
|
testingConnection = false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void done(Boolean licenseValid) {
|
|
Util.toast(context, R.string.settings_testing_ok);
|
|
}
|
|
|
|
@Override
|
|
public void cancel() {
|
|
super.cancel();
|
|
Util.setActiveServer(context, previousInstance);
|
|
}
|
|
|
|
@Override
|
|
protected void error(Throwable error) {
|
|
Log.w(TAG, error.toString(), error);
|
|
new ErrorDialog(context, getResources().getString(R.string.settings_connection_failure) +
|
|
" " + getErrorMessage(error), false);
|
|
}
|
|
};
|
|
task.execute();
|
|
}
|
|
|
|
private void openInBrowser(final int instance) {
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
String url = prefs.getString(Constants.PREFERENCES_KEY_SERVER_URL + instance, null);
|
|
if (url == null) {
|
|
new ErrorDialog(context, R.string.settings_invalid_url);
|
|
return;
|
|
}
|
|
Uri uriServer = Uri.parse(url);
|
|
|
|
Intent browserIntent = new Intent(Intent.ACTION_VIEW, uriServer);
|
|
startActivity(browserIntent);
|
|
}
|
|
|
|
private class ServerSettings {
|
|
private final int instance;
|
|
private final EditTextPreference serverName;
|
|
private final EditTextPreference serverUrl;
|
|
private final EditTextPreference serverLocalNetworkSSID;
|
|
private final EditTextPreference serverInternalUrl;
|
|
private final EditTextPreference username;
|
|
private final PreferenceScreen screen;
|
|
|
|
private ServerSettings(int instance) {
|
|
this.instance = instance;
|
|
screen = (PreferenceScreen) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_SERVER_KEY + instance);
|
|
serverName = (EditTextPreference) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_SERVER_NAME + instance);
|
|
serverUrl = (EditTextPreference) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_SERVER_URL + instance);
|
|
serverLocalNetworkSSID = (EditTextPreference) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_SERVER_LOCAL_NETWORK_SSID + instance);
|
|
serverInternalUrl = (EditTextPreference) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_SERVER_INTERNAL_URL + instance);
|
|
username = (EditTextPreference) SettingsFragment.this.findPreference(Constants.PREFERENCES_KEY_USERNAME + instance);
|
|
|
|
if (serverName != null) {
|
|
serverUrl.setOnPreferenceChangeListener((preference, value) -> {
|
|
try {
|
|
String url = (String) value;
|
|
new URL(url);
|
|
if (url.contains(" ") || url.contains("@") || url.contains("_")) {
|
|
throw new Exception();
|
|
}
|
|
} catch (Exception x) {
|
|
new ErrorDialog(context, R.string.settings_invalid_url);
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
serverInternalUrl.setOnPreferenceChangeListener((preference, value) -> {
|
|
try {
|
|
String url = (String) value;
|
|
// Allow blank internal IP address
|
|
if ("".equals(url) || url == null) {
|
|
return true;
|
|
}
|
|
|
|
new URL(url);
|
|
if (url.contains(" ") || url.contains("@") || url.contains("_")) {
|
|
throw new Exception();
|
|
}
|
|
} catch (Exception x) {
|
|
new ErrorDialog(context, R.string.settings_invalid_url);
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
username.setOnPreferenceChangeListener((preference, value) -> {
|
|
String username = (String) value;
|
|
if (username == null || !username.equals(username.trim())) {
|
|
new ErrorDialog(context, R.string.settings_invalid_username);
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
|
|
public PreferenceScreen getScreen() {
|
|
return screen;
|
|
}
|
|
|
|
public boolean update() {
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
|
|
if (prefs.contains(Constants.PREFERENCES_KEY_SERVER_NAME + instance)) {
|
|
if (serverName != null) {
|
|
serverName.setSummary(serverName.getText());
|
|
serverUrl.setSummary(serverUrl.getText());
|
|
serverLocalNetworkSSID.setSummary(serverLocalNetworkSSID.getText());
|
|
serverInternalUrl.setSummary(serverInternalUrl.getText());
|
|
username.setSummary(username.getText());
|
|
|
|
setTitle(serverName.getText());
|
|
}
|
|
|
|
|
|
String title = prefs.getString(Constants.PREFERENCES_KEY_SERVER_NAME + instance, null);
|
|
String summary = prefs.getString(Constants.PREFERENCES_KEY_SERVER_URL + instance, null);
|
|
|
|
if (title != null) {
|
|
screen.setTitle(title);
|
|
} else {
|
|
screen.setTitle(R.string.settings_server_unused);
|
|
}
|
|
if (summary != null) {
|
|
screen.setSummary(summary);
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|