Move out server preferences to separate fragment.

Now app opens server settings in a separate activity, rather then reusing same preference screen.

ultrasonic/src/main/AndroidManifest.xml

@@ -115,6 +115,8 @@
                 a:resource="@xml/searchable"/>
         </activity>
 
+        <activity a:name=".activity.ServerSettingsActivity" />
+
         <service
             a:name=".service.DownloadServiceImpl"
             a:label="UltraSonic Download Service"

ultrasonic/src/main/java/org/moire/ultrasonic/activity/ServerSettingsActivity.java

@@ -0,0 +1,63 @@
+package org.moire.ultrasonic.activity;
+
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AppCompatActivity;
+import android.view.MenuItem;
+
+import org.moire.ultrasonic.R;
+import org.moire.ultrasonic.fragment.ServerSettingsFragment;
+import org.moire.ultrasonic.util.Util;
+
+public class ServerSettingsActivity extends AppCompatActivity {
+    public static final String ARG_SERVER_ID = "argServerId";
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        applyTheme();
+        super.onCreate(savedInstanceState);
+
+        final Bundle extras = getIntent().getExtras();
+        if (!extras.containsKey(ARG_SERVER_ID)) {
+            finish();
+            return;
+        }
+
+        if (savedInstanceState == null) {
+            configureActionBar();
+
+            final int serverId = extras.getInt(ARG_SERVER_ID);
+            getFragmentManager().beginTransaction()
+                    .add(android.R.id.content, ServerSettingsFragment.newInstance(serverId))
+                    .commit();
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            finish();
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void applyTheme() {
+        String theme = Util.getTheme(this);
+
+        if ("dark".equalsIgnoreCase(theme) || "fullscreen".equalsIgnoreCase(theme)) {
+            setTheme(R.style.UltraSonicTheme);
+        } else if ("light".equalsIgnoreCase(theme) || "fullscreenlight".equalsIgnoreCase(theme)) {
+            setTheme(R.style.UltraSonicTheme_Light);
+        }
+    }
+
+    private void configureActionBar() {
+        final ActionBar actionBar = getSupportActionBar();
+        if (actionBar != null) {
+            actionBar.setDisplayShowHomeEnabled(true);
+            actionBar.setDisplayHomeAsUpEnabled(true);
+        }
+    }
+}

ultrasonic/src/main/java/org/moire/ultrasonic/fragment/ServerSettingsFragment.java

@@ -0,0 +1,282 @@
+package org.moire.ultrasonic.fragment;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.EditTextPreference;
+import android.preference.Preference;
+import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager;
+import android.support.annotation.Nullable;
+import android.util.Log;
+import android.view.View;
+
+import org.moire.ultrasonic.R;
+import org.moire.ultrasonic.service.MusicService;
+import org.moire.ultrasonic.service.MusicServiceFactory;
+import org.moire.ultrasonic.util.Constants;
+import org.moire.ultrasonic.util.ErrorDialog;
+import org.moire.ultrasonic.util.ModalBackgroundTask;
+import org.moire.ultrasonic.util.Util;
+
+import java.net.URL;
+
+/**
+ * Settings for Subsonic server.
+ */
+public class ServerSettingsFragment extends PreferenceFragment
+        implements Preference.OnPreferenceChangeListener,
+        Preference.OnPreferenceClickListener {
+    private static final String LOG_TAG = ServerSettingsFragment.class.getSimpleName();
+    private static final String ARG_SERVER_ID = "serverId";
+
+    private EditTextPreference serverNamePref;
+    private EditTextPreference serverUrlPref;
+    private EditTextPreference serverUsernamePref;
+    private EditTextPreference serverPasswordPref;
+    private CheckBoxPreference equalizerPref;
+    private CheckBoxPreference jukeboxPref;
+    private Preference removeServerPref;
+    private Preference testConnectionPref;
+
+    private int serverId;
+    private SharedPreferences sharedPreferences;
+
+    public static ServerSettingsFragment newInstance(final int serverId) {
+        final ServerSettingsFragment fragment = new ServerSettingsFragment();
+        final Bundle args = new Bundle();
+        args.putInt(ARG_SERVER_ID, serverId);
+        fragment.setArguments(args);
+
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        serverId = getArguments().getInt(ARG_SERVER_ID);
+        sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getActivity());
+
+        addPreferencesFromResource(R.xml.server_settings);
+    }
+
+    @Override
+    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        serverNamePref = (EditTextPreference) findPreference(getString(R.string.settings_server_name));
+        serverUrlPref = (EditTextPreference) findPreference(getString(R.string.settings_server_address));
+        serverUsernamePref = (EditTextPreference) findPreference(getString(R.string.settings_server_username));
+        serverPasswordPref = (EditTextPreference) findPreference(getString(R.string.settings_server_password));
+        equalizerPref = (CheckBoxPreference) findPreference(getString(R.string.equalizer_enabled));
+        jukeboxPref = (CheckBoxPreference) findPreference(getString(R.string.jukebox_is_default));
+        removeServerPref = findPreference(getString(R.string.settings_server_remove_server));
+        testConnectionPref = findPreference(getString(R.string.settings_test_connection_title));
+
+        setupPreferencesValues();
+        setupPreferencesListeners();
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        if (preference == serverNamePref) {
+            sharedPreferences.edit()
+                    .putString(Constants.PREFERENCES_KEY_SERVER_NAME + serverId, (String) newValue)
+                    .apply();
+            updateName();
+            return true;
+        } else if (preference == serverUrlPref) {
+            final String url = (String) newValue;
+            try {
+                new URL(url);
+                if (!url.equals(url.trim()) || url.contains("@")) {
+                    throw new Exception();
+                }
+            } catch (Exception x) {
+                new ErrorDialog(getActivity(), R.string.settings_invalid_url, false);
+                return false;
+            }
+
+            sharedPreferences.edit()
+                    .putString(Constants.PREFERENCES_KEY_SERVER_URL + serverId, url)
+                    .apply();
+            updateUrl();
+            return true;
+        } else if (preference == serverUsernamePref) {
+            String username = (String) newValue;
+            if (username == null || !username.equals(username.trim())) {
+                new ErrorDialog(getActivity(), R.string.settings_invalid_username, false);
+                return false;
+            }
+
+            sharedPreferences.edit()
+                    .putString(Constants.PREFERENCES_KEY_USERNAME + serverId, username)
+                    .apply();
+            updateUsername();
+            return true;
+        } else if (preference == serverPasswordPref) {
+            sharedPreferences.edit()
+                    .putString(Constants.PREFERENCES_KEY_PASSWORD + serverId, (String) newValue)
+                    .apply();
+            updatePassword();
+            return true;
+        } else if (preference == equalizerPref) {
+            sharedPreferences.edit()
+                    .putBoolean(Constants.PREFERENCES_KEY_SERVER_ENABLED + serverId, (Boolean) newValue)
+                    .apply();
+            return true;
+        } else if (preference == jukeboxPref) {
+            sharedPreferences.edit()
+                    .putBoolean(Constants.PREFERENCES_KEY_JUKEBOX_BY_DEFAULT + serverId, (Boolean) newValue)
+                    .apply();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onPreferenceClick(Preference preference) {
+        if (preference == removeServerPref) {
+            removeServer();
+            return true;
+        } else if (preference == testConnectionPref) {
+            testConnection();
+            return true;
+        }
+        return false;
+    }
+
+    private void setupPreferencesValues() {
+        updateName();
+        updateUrl();
+        updateUsername();
+        updatePassword();
+
+        if (!sharedPreferences.contains(Constants.PREFERENCES_KEY_SERVER_ENABLED + serverId)) {
+            sharedPreferences.edit()
+                    .putBoolean(Constants.PREFERENCES_KEY_SERVER_ENABLED + serverId, true)
+                    .apply();
+        }
+        equalizerPref.setChecked(sharedPreferences
+                .getBoolean(Constants.PREFERENCES_KEY_SERVER_ENABLED + serverId, true));
+
+        jukeboxPref.setChecked(sharedPreferences
+                .getBoolean(Constants.PREFERENCES_KEY_JUKEBOX_BY_DEFAULT + serverId, false));
+    }
+
+    private void updatePassword() {
+        serverPasswordPref.setText(sharedPreferences
+                .getString(Constants.PREFERENCES_KEY_PASSWORD + serverId, "***"));
+        serverPasswordPref.setSummary("***");
+    }
+
+    private void updateUsername() {
+        serverUsernamePref.setText(sharedPreferences
+                .getString(Constants.PREFERENCES_KEY_USERNAME + serverId,
+                        getString(R.string.settings_server_username)));
+    }
+
+    private void updateUrl() {
+        final String serverUrl = sharedPreferences
+                .getString(Constants.PREFERENCES_KEY_SERVER_URL + serverId,
+                        getString(R.string.settings_server_address_unset));
+        serverUrlPref.setText(serverUrl);
+        serverUrlPref.setSummary(serverUrl);
+    }
+
+    private void updateName() {
+        final String serverName = sharedPreferences
+                .getString(Constants.PREFERENCES_KEY_SERVER_NAME + serverId,
+                        getString(R.string.settings_server_unused));
+        serverNamePref.setText(serverName);
+        serverNamePref.setSummary(serverName);
+    }
+
+    private void setupPreferencesListeners() {
+        serverNamePref.setOnPreferenceChangeListener(this);
+        serverUrlPref.setOnPreferenceChangeListener(this);
+        serverUsernamePref.setOnPreferenceChangeListener(this);
+        serverPasswordPref.setOnPreferenceChangeListener(this);
+        equalizerPref.setOnPreferenceChangeListener(this);
+        jukeboxPref.setOnPreferenceChangeListener(this);
+
+        removeServerPref.setOnPreferenceClickListener(this);
+        testConnectionPref.setOnPreferenceClickListener(this);
+    }
+
+    private void testConnection() {
+        ModalBackgroundTask<Boolean> task = new ModalBackgroundTask<Boolean>(getActivity(), false) {
+            private int previousInstance;
+
+            @Override
+            protected Boolean doInBackground() throws Throwable {
+                updateProgress(R.string.settings_testing_connection);
+
+                final Context context = getActivity();
+                previousInstance = Util.getActiveServer(context);
+                Util.setActiveServer(context, serverId);
+                try {
+                    MusicService musicService = MusicServiceFactory.getMusicService(context);
+                    musicService.ping(context, this);
+                    return musicService.isLicenseValid(context, null);
+                } finally {
+                    Util.setActiveServer(context, previousInstance);
+                }
+            }
+
+            @Override
+            protected void done(Boolean licenseValid) {
+                if (licenseValid) {
+                    Util.toast(getActivity(), R.string.settings_testing_ok);
+                } else {
+                    Util.toast(getActivity(), R.string.settings_testing_unlicensed);
+                }
+            }
+
+            @Override
+            protected void cancel() {
+                super.cancel();
+                Util.setActiveServer(getActivity(), previousInstance);
+            }
+
+            @Override
+            protected void error(Throwable error) {
+                Log.w(LOG_TAG, error.toString(), error);
+                new ErrorDialog(getActivity(), String.format("%s %s", getResources().getString(R.string.settings_connection_failure), getErrorMessage(error)), false);
+            }
+        };
+        task.execute();
+    }
+
+    private void removeServer() {
+        int activeServers = sharedPreferences
+                .getInt(Constants.PREFERENCES_KEY_ACTIVE_SERVERS, 0);
+
+        // Reset values to null so when we ask for them again they are new
+        sharedPreferences.edit()
+                .remove(Constants.PREFERENCES_KEY_SERVER_NAME + serverId)
+                .remove(Constants.PREFERENCES_KEY_SERVER_URL + serverId)
+                .remove(Constants.PREFERENCES_KEY_USERNAME + serverId)
+                .remove(Constants.PREFERENCES_KEY_PASSWORD + serverId)
+                .remove(Constants.PREFERENCES_KEY_SERVER_ENABLED + serverId)
+                .remove(Constants.PREFERENCES_KEY_JUKEBOX_BY_DEFAULT + serverId)
+                .apply();
+
+        if (serverId < activeServers) {
+            int activeServer = Util.getActiveServer(getActivity());
+            for (int i = serverId; i <= activeServers; i++) {
+                Util.removeInstanceName(getActivity(), i, activeServer);
+            }
+        }
+
+        activeServers--;
+
+        sharedPreferences.edit()
+                .putInt(Constants.PREFERENCES_KEY_ACTIVE_SERVERS, activeServers)
+                .apply();
+
+        getActivity().finish();
+    }
+}

ultrasonic/src/main/java/org/moire/ultrasonic/fragment/SettingsFragment.java

@@ -1,7 +1,6 @@
 package org.moire.ultrasonic.fragment;
 
-import android.app.Dialog;
-import android.content.Context;
+import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Build;
 import android.os.Bundle;
@@ -12,32 +11,24 @@ import android.preference.Preference;
 import android.preference.PreferenceCategory;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceManager;
-import android.preference.PreferenceScreen;
 import android.provider.SearchRecentSuggestions;
 import android.support.annotation.Nullable;
-import android.text.InputType;
 import android.util.Log;
 import android.view.View;
 
 import org.moire.ultrasonic.R;
+import org.moire.ultrasonic.activity.ServerSettingsActivity;
 import org.moire.ultrasonic.activity.SubsonicTabActivity;
 import org.moire.ultrasonic.provider.SearchSuggestionProvider;
 import org.moire.ultrasonic.service.DownloadService;
 import org.moire.ultrasonic.service.DownloadServiceImpl;
-import org.moire.ultrasonic.service.MusicService;
-import org.moire.ultrasonic.service.MusicServiceFactory;
 import org.moire.ultrasonic.util.Constants;
-import org.moire.ultrasonic.util.ErrorDialog;
 import org.moire.ultrasonic.util.FileUtil;
 import org.moire.ultrasonic.util.ImageLoader;
-import org.moire.ultrasonic.util.ModalBackgroundTask;
 import org.moire.ultrasonic.util.TimeSpanPreference;
 import org.moire.ultrasonic.util.Util;
 
 import java.io.File;
-import java.net.URL;
-import java.util.LinkedHashMap;
-import java.util.Map;
 
 /**
  * Shows main app settings.
@@ -45,7 +36,6 @@ import java.util.Map;
 public class SettingsFragment extends PreferenceFragment
         implements SharedPreferences.OnSharedPreferenceChangeListener {
     private static final String LOG_TAG = SettingsFragment.class.getSimpleName();
-    private final Map<String, ServerSettings> serverSettings = new LinkedHashMap<>();
 
     private ListPreference theme;
     private ListPreference videoPlayer;
@@ -75,9 +65,7 @@ public class SettingsFragment extends PreferenceFragment
     private EditTextPreference sharingDefaultGreeting;
     private TimeSpanPreference sharingDefaultExpiration;
     private PreferenceCategory serversCategory;
-    private Preference addServerPreference;
 
-    private boolean testingConnection;
     private int maxServerCount = 10;
     private SharedPreferences settings;
     private int activeServers;
@@ -89,7 +77,6 @@ public class SettingsFragment extends PreferenceFragment
         addPreferencesFromResource(R.xml.settings);
 
         settings = PreferenceManager.getDefaultSharedPreferences(getActivity());
-        activeServers = settings.getInt(Constants.PREFERENCES_KEY_ACTIVE_SERVERS, 0);
     }
 
     @Override
@@ -128,7 +115,6 @@ public class SettingsFragment extends PreferenceFragment
         sharingDefaultGreeting.setText(Util.getShareGreeting(getActivity()));
         setupClearSearchPreference();
         setupGaplessControlSettingsV14();
-        setupServersCategory();
     }
 
     @Override
@@ -142,6 +128,7 @@ public class SettingsFragment extends PreferenceFragment
     public void onResume() {
         super.onResume();
 
+        setupServersCategory();
         SharedPreferences preferences = Util.getPreferences(getActivity());
         preferences.registerOnSharedPreferenceChangeListener(this);
     }
@@ -210,33 +197,34 @@ public class SettingsFragment extends PreferenceFragment
     }
 
     private void setupServersCategory() {
-        addServerPreference = new Preference(getActivity());
+        activeServers = settings.getInt(Constants.PREFERENCES_KEY_ACTIVE_SERVERS, 0);
+        final Preference addServerPreference = new Preference(getActivity());
         addServerPreference.setKey(Constants.PREFERENCES_KEY_ADD_SERVER);
         addServerPreference.setPersistent(false);
         addServerPreference.setTitle(getResources().getString(R.string.settings_server_add_server));
         addServerPreference.setEnabled(activeServers < maxServerCount);
 
+        serversCategory.removeAll();
         serversCategory.addPreference(addServerPreference);
 
         for (int i = 1; i <= activeServers; i++) {
-            final int instanceValue = i;
-
-            serversCategory.addPreference(addServer(i));
-
-            Preference testConnectionPreference = findPreference(Constants.PREFERENCES_KEY_TEST_CONNECTION + i);
-
-            if (testConnectionPreference != null) {
-                testConnectionPreference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
-                    @Override
-                    public boolean onPreferenceClick(Preference preference) {
-                        testConnection(instanceValue);
-                        return false;
-                    }
-                });
-            }
-
-            String instance = String.valueOf(i);
-            serverSettings.put(instance, new ServerSettings(instance));
+            final int serverId = i;
+            Preference preference = new Preference(getActivity());
+            preference.setPersistent(false);
+            preference.setTitle(settings.getString(Constants.PREFERENCES_KEY_SERVER_NAME + serverId,
+                    getString(R.string.settings_server_name)));
+            preference.setSummary(settings.getString(Constants.PREFERENCES_KEY_SERVER_URL + serverId,
+                    getString(R.string.settings_server_address_unset)));
+            preference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
+                @Override
+                public boolean onPreferenceClick(Preference preference) {
+                    final Intent intent = new Intent(getActivity(), ServerSettingsActivity.class);
+                    intent.putExtra(ServerSettingsActivity.ARG_SERVER_ID, serverId);
+                    startActivity(intent);
+                    return true;
+                }
+            });
+            serversCategory.addPreference(preference);
         }
 
         addServerPreference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
@@ -258,260 +246,31 @@ public class SettingsFragment extends PreferenceFragment
                     serversCategory.removePreference(addServerPreference);
                 }
 
-                serversCategory.addPreference(addServer(activeServers));
+                Preference newServerPrefs = new Preference(getActivity());
+                newServerPrefs.setTitle(getString(R.string.settings_server_name));
+                newServerPrefs.setSummary(getString(R.string.settings_server_address_unset));
+                newServerPrefs.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
+                    @Override
+                    public boolean onPreferenceClick(Preference preference) {
+                        final Intent intent = new Intent(getActivity(), ServerSettingsActivity.class);
+                        intent.putExtra(ServerSettingsActivity.ARG_SERVER_ID, activeServers);
+                        startActivity(intent);
+                        return true;
+                    }
+                });
+                serversCategory.addPreference(newServerPrefs);
 
                 if (addServerPreference != null) {
                     serversCategory.addPreference(addServerPreference);
                     addServerPreference.setEnabled(activeServers < maxServerCount);
                 }
 
-                String instance = String.valueOf(activeServers);
-                serverSettings.put(instance, new ServerSettings(instance));
-
                 return true;
             }
         });
     }
 
-    private PreferenceScreen addServer(final int instance) {
-        final Context context = getActivity();
-        final PreferenceScreen screen = getPreferenceManager().createPreferenceScreen(context);
-
-        if (screen != null) {
-            screen.setTitle(R.string.settings_server_unused);
-            screen.setKey(Constants.PREFERENCES_KEY_SERVER + 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);
-
-        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);
-
-        if (serverUrlPreference.getText() == null) {
-            serverUrlPreference.setText("http://yourhost");
-        }
-
-        serverUrlPreference.setSummary(serverUrlPreference.getText());
-
-        if (screen != null) {
-            screen.setSummary(serverUrlPreference.getText());
-        }
-
-        final EditTextPreference serverUsernamePreference = new EditTextPreference(context);
-        serverUsernamePreference.setKey(Constants.PREFERENCES_KEY_USERNAME + instance);
-        serverUsernamePreference.setTitle(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 CheckBoxPreference serverEnabledPreference = new CheckBoxPreference(context);
-        serverEnabledPreference.setDefaultValue(true);
-        serverEnabledPreference.setKey(Constants.PREFERENCES_KEY_SERVER_ENABLED + instance);
-        serverEnabledPreference.setTitle(R.string.equalizer_enabled);
-
-        final CheckBoxPreference jukeboxEnabledPreference = new CheckBoxPreference(context);
-        jukeboxEnabledPreference.setDefaultValue(false);
-        jukeboxEnabledPreference.setKey(Constants.PREFERENCES_KEY_JUKEBOX_BY_DEFAULT + instance);
-        jukeboxEnabledPreference.setTitle(R.string.jukebox_is_default);
-
-        Preference serverRemoveServerPreference = new Preference(context);
-        serverRemoveServerPreference.setKey(Constants.PREFERENCES_KEY_REMOVE_SERVER + instance);
-        serverRemoveServerPreference.setPersistent(false);
-        serverRemoveServerPreference.setTitle(R.string.settings_server_remove_server);
-
-        serverRemoveServerPreference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
-            @Override
-            public boolean onPreferenceClick(Preference preference) {
-                if (activeServers == 0) {
-                    return false;
-                }
-
-                // 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);
-                serverEnabledPreference.setChecked(true);
-                jukeboxEnabledPreference.setChecked(false);
-
-                if (instance < activeServers) {
-
-                    int activeServer = Util.getActiveServer(getActivity());
-                    for (int i = instance; i <= activeServers; i++) {
-                        Util.removeInstanceName(getActivity(), i, activeServer);
-                    }
-                }
-
-                activeServers--;
-
-                if (screen != null) {
-                    serversCategory.removePreference(screen);
-                    Dialog dialog = screen.getDialog();
-
-                    if (dialog != null) {
-                        dialog.dismiss();
-                    }
-                }
-
-                settings.edit()
-                        .putInt(Constants.PREFERENCES_KEY_ACTIVE_SERVERS, activeServers)
-                        .apply();
-
-                addServerPreference.setEnabled(activeServers < maxServerCount);
-
-                return true;
-            }
-        });
-
-        Preference serverTestConnectionPreference = new Preference(getActivity());
-        serverTestConnectionPreference.setKey(Constants.PREFERENCES_KEY_TEST_CONNECTION + instance);
-        serverTestConnectionPreference.setPersistent(false);
-        serverTestConnectionPreference.setTitle(R.string.settings_test_connection_title);
-
-        serverTestConnectionPreference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
-            @Override
-            public boolean onPreferenceClick(Preference preference) {
-                testConnection(instance);
-                return false;
-            }
-        });
-
-        if (screen != null) {
-            screen.addPreference(serverNamePreference);
-            screen.addPreference(serverUrlPreference);
-            screen.addPreference(serverUsernamePreference);
-            screen.addPreference(serverPasswordPreference);
-            screen.addPreference(serverEnabledPreference);
-            screen.addPreference(jukeboxEnabledPreference);
-            screen.addPreference(serverRemoveServerPreference);
-            screen.addPreference(serverTestConnectionPreference);
-        }
-
-        return screen;
-    }
-
-    private void testConnection(final int instance) {
-        ModalBackgroundTask<Boolean> task = new ModalBackgroundTask<Boolean>(getActivity(), false) {
-            private int previousInstance;
-
-            @Override
-            protected Boolean doInBackground() throws Throwable {
-                updateProgress(R.string.settings_testing_connection);
-
-                final Context context = getActivity();
-                previousInstance = Util.getActiveServer(context);
-                testingConnection = true;
-                Util.setActiveServer(context, instance);
-                try {
-                    MusicService musicService = MusicServiceFactory.getMusicService(context);
-                    musicService.ping(context, this);
-                    return musicService.isLicenseValid(context, null);
-                } finally {
-                    Util.setActiveServer(context, previousInstance);
-                    testingConnection = false;
-                }
-            }
-
-            @Override
-            protected void done(Boolean licenseValid) {
-                if (licenseValid) {
-                    Util.toast(getActivity(), R.string.settings_testing_ok);
-                } else {
-                    Util.toast(getActivity(), R.string.settings_testing_unlicensed);
-                }
-            }
-
-            @Override
-            protected void cancel() {
-                super.cancel();
-                Util.setActiveServer(getActivity(), previousInstance);
-            }
-
-            @Override
-            protected void error(Throwable error) {
-                Log.w(LOG_TAG, error.toString(), error);
-                new ErrorDialog(getActivity(), String.format("%s %s", getResources().getString(R.string.settings_connection_failure), getErrorMessage(error)), false);
-            }
-        };
-        task.execute();
-    }
-
-    private class ServerSettings {
-        private EditTextPreference serverName;
-        private EditTextPreference serverUrl;
-        private EditTextPreference username;
-        private PreferenceScreen screen;
-
-        private ServerSettings(String instance) {
-            screen = (PreferenceScreen) findPreference("server" + instance);
-            serverName = (EditTextPreference) findPreference(Constants.PREFERENCES_KEY_SERVER_NAME +
-                    instance);
-            serverUrl = (EditTextPreference) findPreference(Constants.PREFERENCES_KEY_SERVER_URL +
-                    instance);
-            username = (EditTextPreference) findPreference(Constants.PREFERENCES_KEY_USERNAME +
-                    instance);
-
-            serverUrl.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
-                @Override
-                public boolean onPreferenceChange(Preference preference, Object value) {
-                    try {
-                        String url = (String) value;
-                        new URL(url);
-                        if (!url.equals(url.trim()) || url.contains("@")) {
-                            throw new Exception();
-                        }
-                    } catch (Exception x) {
-                        new ErrorDialog(getActivity(), R.string.settings_invalid_url, false);
-                        return false;
-                    }
-                    return true;
-                }
-            });
-
-            username.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
-                @Override
-                public boolean onPreferenceChange(Preference preference, Object value) {
-                    String username = (String) value;
-                    if (username == null || !username.equals(username.trim())) {
-                        new ErrorDialog(getActivity(), R.string.settings_invalid_username, false);
-                        return false;
-                    }
-                    return true;
-                }
-            });
-        }
-
-        public void update() {
-            serverName.setSummary(serverName.getText());
-            serverUrl.setSummary(serverUrl.getText());
-            username.setSummary(username.getText());
-            screen.setSummary(serverUrl.getText());
-            screen.setTitle(serverName.getText());
-        }
-    }
-
     private void update() {
-        if (testingConnection) {
-            return;
-        }
-
         theme.setSummary(theme.getEntry());
         videoPlayer.setSummary(videoPlayer.getEntry());
         maxBitrateWifi.setSummary(maxBitrateWifi.getEntry());
@@ -545,10 +304,6 @@ public class SettingsFragment extends PreferenceFragment
             sendBluetoothAlbumArt.setChecked(false);
             sendBluetoothAlbumArt.setEnabled(false);
         }
-
-        for (ServerSettings ss : serverSettings.values()) {
-            ss.update();
-        }
     }
 
     private static void setImageLoaderConcurrency(int concurrency) {

ultrasonic/src/main/res/values/strings.xml

@@ -392,6 +392,7 @@
     <string name="settings.image_loader_concurrency_12">12</string>
     <string name="albumArt">albumArt</string>
     <string name="common_multiple_years">Multiple Years</string>
+    <string name="settings.server_address_unset">http://yourhost</string>
 
     <plurals name="select_album_n_songs">
         <item quantity="zero">No songs</item>

ultrasonic/src/main/res/xml/server_settings.xml

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:title="@string/common.appname"
+    >
+    <EditTextPreference
+        android:key="@string/settings.server_name"
+        android:persistent="false"
+        android:title="@string/settings.server_name"
+        android:defaultValue="@string/settings.server_unused"
+        android:text="@string/settings.server_unused"
+        android:summary="@string/settings.server_unused"
+        />
+    <EditTextPreference
+        android:key="@string/settings.server_address"
+        android:persistent="false"
+        android:inputType="textUri"
+        android:defaultValue="@string/settings.server_address_unset"
+        android:title="@string/settings.server_address"
+        android:text="@string/settings.server_address_unset"
+        android:summary="@string/settings.server_address_unset"
+        />
+    <EditTextPreference
+        android:key="@string/settings.server_username"
+        android:persistent="false"
+        android:title="@string/settings.server_username"
+        />
+    <EditTextPreference
+        android:key="@string/settings.server_password"
+        android:persistent="false"
+        android:inputType="textPassword"
+        android:summary="***"
+        android:title="@string/settings.server_password"
+        />
+    <CheckBoxPreference
+        android:key="@string/equalizer.enabled"
+        android:persistent="false"
+        android:defaultValue="true"
+        android:title="@string/equalizer.enabled"
+        />
+    <CheckBoxPreference
+        android:key="@string/jukebox.is_default"
+        android:persistent="false"
+        android:defaultValue="false"
+        android:title="@string/jukebox.is_default"
+        />
+    <Preference
+        android:key="@string/settings.server_remove_server"
+        android:persistent="false"
+        android:title="@string/settings.server_remove_server"
+        />
+    <Preference
+        android:key="@string/settings.test_connection_title"
+        android:persistent="false"
+        android:title="@string/settings.test_connection_title"
+        />
+</PreferenceScreen>