Anfänger Fragen - Menü

Zitat von Killua

Wie bewerkstellige ich nun folgendes...
Ich klicke auf einen der erstellten Menüpunkte - daraufhin öffnet sich eine Einstellungsdialog

Du musst die Methode onOptionsItemSelected() implementieren und dann die id des Menüpunkts abfragen. Daraufhin kannst du z.B. eine Activity starten, die es dir erlaubt die Preferences zu bearbeiten.

Angenommen die id deines Menüpunkts ist main_menu_options_prefs und die Klasse, die deine Preferences-Activity repräsentiert ist EditPreferences, dann geht das so:

@Override
public boolean onOptionsItemSelected (MenuItem item)
{
    switch (item.getItemId())
    {
        // Preferences Menüpunkt 'main_menu_options_prefs' startet Activity 'EditPreferences'
        case R.id.main_menu_options_prefs:
            startActivity (new Intent (this, EditPreferences.class));
            return (true);


        // andere Menüpunkte hier
    }
        
    return (super.onOptionsItemSelected(item));
}

Zitat

in dem ich Dateneingeben kann und speichern kann, sodass ich diese gegebenfalls zu einem späteren Zeitpunkt für etwas verwenden kann (siehe Beispielbild).

Hast du den Teil schon?

Zitat von Killua

Allerdings hatte ich bisher mit Zahlen bei der Zuweißung der casefälle gearbeitet. Daher eine kurze Frage - was bedeutet das "R.id." vor dem main_menu_options_prefs.

Ok, sehe schon wir müssen etwas weiter ausholen. Die Klasse "R" wird automatisch von der Android Build-Umgebung erzeugt. R steht dabei für "Resource" und somit enhält die Klasse alle XML Dateien, die du im Ordner "res/" erzeugst.

Auf diese Weise kannst du ganz einfach Menüs erstellen, ohne dich um irgendwelche Nummern kümmern zu müssen. Das ganze geht auch mit Strings, Preferences, Layouts, usw. - eben alles was du in die XML Dateien unterhalb von "res/" reinschreiben kannst. Jeder Eintrag in den XML Dateien erhält dabei einen eindeutigen Identifier. Diese identifier kannst du über die Klasse "R" ansprechen und Android weiss dann was gemeint ist.

Wie erstellt man jetzt also einen Menüeintrag "sauber"? Zuerst mal überlegst du dir einen Namen für die XML Datei, die alle Menüpunkte für deine Activity enthalten soll. Da unser Beispiel-Menü in der Main-Activity eingeblendet werden soll und Einträge für das Optionen-Menü enthält, nenn ich das ganze jetzt mal "main_menu_options.xml" (der Name ist egal, du solltest dir aber ein Schema überlegen). In dieser Datei soll es einen Menüpunkt geben mit der Aufschrift "Einstellungen". Du erstellst also die Datei "res/menu/main_menu_options.xml" und schreibst da folgendes rein:

res/menu/main_menu_options.xml:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/main_menu_options_prefs"
        android:icon="@android:drawable/ic_menu_preferences"
        android:title="@string/main_menu_options_prefs_title"/>
</menu>

Damit definieren wir also ein neues Menü mit einem Menüeintrag für "Einstellungen". Der Name des Menüeintrags ist "main_menu_options_prefs", er hat ein Icon mit der Id "drawable/ic_menu_preferences" und einen Titel mit der id "main_menu_options_prefs_title". Die Id des Menüeintrags darfst du frei wählen, es macht aber Sinn, wenn sie in dein Schema passt - daher "main_menu_options_prefs". Das Icon wird von Android zur Verfügung gestellt, daher beginnt auch der Eintrag mit "@android:". Eine Liste aller Icons findest du irgendwo in der SDK Dokumentation. Den Title wiederum definieren wir selber (soll "Einstellungen" sein und daher vergeben wir wieder eine Id, die in unser Schema passt: "main_menu_options_prefs_title". Damit haben wir jetzt einen gültigen Menüeintrag erstellt - allerdings funktioniert er noch nicht, da wir uns zwar eine schöne Id für unseren Titel ausgedacht haben, aber diese Id noch nicht definiert haben. Wir müssen also "main_menu_options_prefs_title" erstmal definieren.

Wie alle Strings, die du irgendwo in deinem Programm definierst, schreibst du die Übersetzung von "main_menu_options_prefs_title" einfach in die die strings.xml welche du unter "res/values/strings.xml" findest oder neu erstellen musst. Das sieht dann so aus:

res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="main_menu_options_prefs_title">Einstellungen</string>
</resources>

Warum so umständlich? Warum schreiben wir nicht einfach den String "Einstellungen" in die res/menu/main_menu_options.xml Datei?

Das geht zwar, ist aber schlechter Stil. Wann immer du einen String benötigst - ganz egal wo in deinem Programm - solltest du einen Eintrag in der strings.xml definieren und diesen dann über R.string.<id> ansprechen. Das hat den Vorteil, dass du dann nur deine strings.xml übersetzen musst und schon kannst du dein Programm für alle möglichen Sprachen anbieten oder zur Laufzeit zwischen z.B. Deutsch und Englisch hin- und herschalten.

Nachdem wir jetzt ein Menü definiert haben und einen gültigen Menüeintrag können wir das ganze jetzt in unserer Activity mit Hilfe der Methoden onCreateOptionsMenu() und onOptionsItemSelected() aktivieren:

@Override
    public boolean onCreateOptionsMenu(Menu menu)
    {
        getMenuInflater().inflate(R.menu.main_menu_options, menu);


        return (super.onCreateOptionsMenu(menu));
    }




    @Override
    public boolean onOptionsItemSelected (MenuItem item)
    {
        switch (item.getItemId())
        {
            case R.id.main_menu_options_prefs:
                startActivity (new Intent (this, EditPreferences.class));
                return (true);
        }


        return (super.onOptionsItemSelected(item));
    }

Zitat

Der teil mit startActivity war mir nicht bekannt. Daher habe ich nun , um bei dem Namen zubleiben, eine EditPreferences.class angelegt.

Um zu deiner letzten Frage zu kommen, nein diesen Teil habe ich noch nicht.
Daher meine Frage wie der weiter verlauf nun aussehen würde (aufbau der Preferences).

Dazu schreibe ich gleichmal was. Mach hier mit dem ersten Teil erstmal Schluss, sonst wird der Post zu lange. Kannst ja schonmal dein Menü anpassen.

Zweiter Teil:

So, wie sieht nun die Klasse EditPreferences aus. Erstaunlich einfach, nämlich so:

package my.actvity;


import android.preference.PreferenceActivity;


public class EditPreferences extends PreferenceActivity
{
    @Override
    public void onCreate (Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);


        // create widgets from preferences XML file
        addPreferencesFromResource(R.xml.preferences);
    }
}

Die Android Klasse "PreferenceActivity" erledigt alle Aufgaben für uns. Das einzige was wir ihr mitteilen müssen ist, wo sie die XML Datei findet, die alle unsere Preferences enthält - nämlich "R.xml.preferences". Der Identifier ist aus dem Ordner und dem Namen der Datei zusammengesetzt. Den Namen der Datei darfst du frei wählen (in diesem Fall "preferences") und der Ordner ist immer "xml", da es sich um eine allgmeine XML Datei handelt. Du legst also im Ordner "res/", unterhalb von "xml/" eine Datei mit dem Namen "preferences.xml" an. Die könnte z.B. so aussehen:

res/xml/preferences.xml:

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen
    xmlns:android="http://schemas.android.com/apk/res/android">


    <PreferenceCategory android:title="@string/pref_account_title">
                <EditTextPreference
                        android:key="pref_account_username"
                        android:summary="@string/pref_account_username_summary"
                        android:title="@string/pref_account_username_title"
                        android:dialogTitle="@string/pref_account_username_dialogTitle"
                        android:singleLine="true">
                        </EditTextPreference>
                <EditTextPreference
                        android:key="pref_account_password"
                        android:summary="@string/pref_account_password_summary"
                        android:title="@string/pref_account_password_title"
                        android:dialogTitle="@string/pref_account_password_dialogTitle"
                        android:singleLine="true"
                        android:password="true">
                        </EditTextPreference>
        </PreferenceCategory>
</PreferenceScreen>

Das ganze ist aus einem Projekt von mir bei dem der Benutzer seinen Benutzernamen und ein Passwort eingeben muss, damit ich im Namen des Benutzers auf einen Dienst im Internet verbinden kann. Symbolisch enthält dieser Einstellungsdialog also eine Kategorie für alle Account-Informationen und zwei Textfelder für den Login und das Passwort.

Die Kategorie hat einen Titel, dessen String in der strings.xml mit der Id "pref_account_title" hinterlegt ist. Dann gibt es das erste Textfeld für den Benutzernamen, welches die Id "pref_account_username" hat. Dieses Textfeld benötigt eine Zusammenfassung (summary) als Hilfetext, einen Titel (title) für den Namen der Einstellung und einen Dialog Titel (dialogTitle) für den Dialog der eingeblendet wird, wenn der Benutzer einen Wert eingeben will. Diese Strings sind unter den Ids "pref_account_username_summary", "pref_account_username_title" und "pref_account_username_dialogTitle" hinterlegt. Das gleiche gilt für das Passwort Feld mit der Id "pref_account_password".

Wir erweitern also unsere strings.xml, so dass das ganze so aussieht:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="main_menu_options_prefs_title">Einstellungen</string>


    <string name="pref_account_title">Account Settings</string>


    <string name="pref_account_username_title">Username</string>
    <string name="pref_account_username_summary">IMAP/Kolab server username.</string>
    <string name="pref_account_username_dialogTitle">Enter Username:</string>


    <string name="pref_account_password_title">Password</string>
    <string name="pref_account_password_summary">IMAP/Kolab server password.</string>
    <string name="pref_account_password_dialogTitle">Enter Password:</string>


</resources>

Damit haben wir jetzt alle Daten angegeben und Android kann den Einstellungsdialog anzeigen, sobald man auf den Menüpunkt in der Activity klickt. Alle Daten die der Benutzer angibt werden automatisch gespeichert.

Eine Liste aller möglichen Einstellungsdialoge findest du in der SDK Dokumentation. Im wesentlichen kannst du alle Dialoge nutzen, die Android anbietet (TextDialog, Radio-Buttons, Multiple-Choice, DropDown-Lists, usw.).[hr]

Zitat von Killua

Ich hab jetzt auch soweit alles angepasst - eine fragen hätte ich aber....und zwar das "@+id" in der xml datei bedeutet das die id einfach hochgezählt wird ?

Nein, das heisst einfach nur, dass danach der Name eine Identifiers angegeben wird. Wofür genau das "+" Zeichen steht hab ich vergessen. Ist aber auch nicht wichtig. In der SDK-Dokumentation ist das irgendwo erklärt. Da man aber eh immer "@+id/" schreiben muss habe ich das verdrängt.

Zitat von Killua

Was macht es für einen Unterschied wenn ich z.b. in der preferences.xml eine Checkbox anlege...

PHP

<CheckBoxPreference  
android:key="pref_checkbox"  
android:title="@string/pref_checkbox_title"  
android:summary="@string/pref_checkbox_title_summary">
</CheckBoxPreference>

oder direkt in meinem Programm...

PHP

CheckBoxPreference auth = new CheckBoxPreference(this);
auth.setTitle(R.string.pref_checkbox_title);
auth.setSummary(R.string.pref_checkbox_title_summary);
auth.setKey("pref_checkbox_test");
getPreferenceScreen().addItemFromInflater(auth);

Die XML Lösung ist sauberer, weil:

• Weniger Fehleranfällig, weil weniger Code.
• Zukunftssicherer bei eventuellen SDK-Änderungen.
• Dein Code kann sich auf die Geschäftslogik konzentrieren => Besser lesbarer Code.

Zitat

Und meine zweite Frage wäre wie bzw. über was ich die Checkbox (welche ich in der xml datei angelegt habe) anspreche ?

Mit Hilfe des Identifiers. Dabei hast du fünf Möglichkeiten:

• Mit findPreference() innerhalb der PreferenceActivity um die GLOBALEN Preferences anzusprechen
• Mit getPreferenceManager().getSharedPreferences() innerhalb der PreferenceActivity um die GLOBALEN Preferences anzusprechen.
• Mit getPreferences() innerhalb einer Activity um die LOKALEN Preferences DIESER Activity anzusprechen.
• Mit getSharedPreferences() innerhalb einer Activity um die GLOBALEN Preferences anzusprechen.
• Mit PreferenceManager.getDefaultSharedPreferences() um die GLOBALEN Preferences aus einem beliebigen Context anzusprechen.

Deine Checkbox hat also die Id "pref_checkbox".

INNERHALB der PreferenceActivity kannst du die Checkbox so ansprechen:

// Möglichkeit 1: findPreferences()
// Damit bekommst du ein Handle auf eine preference Instanz
Preference pref_checkbox = findPreference ("pref_checkbox");


// Möglichkeit 2: getPreferenceManager().getSharedPreferences()
// Damit kannst du den Wert direkt abfragen ohne Preferences Instanz.
SharedPreferences preferences = getPreferenceManager().getSharedPreferences();
boolean value = preferences.getBoolean ("pref_checkbox", false);

Aus einem BELIEBIGEN Context kannst du so auf die SharedPreferences zugreifen:

// Möglichkeit 5: Von irgendwo auf die GLOBALEN Preferences zugreifen.
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences();
boolean value = preferences.getBoolean ("pref_checkbox", false);

Möglichkeit 3 und 4 gehen analog. Bei Möglichkeit 5 kannst du auch findPreferences() verwenden, sofern du eine Instanz des PreferenceManagers hast.

Zitat von Killua

gibt es den eine Funktion welche automatisch ausgeführt wird sobald der Button gedrückt wird ? - also quasi sowas wie ein interrupt

Entweder so:

public class EditPreferences extends PreferenceActivity
        implements Preference.OnPreferenceClickListener
{
    @Override
    public void onCreate (Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);


        addPreferencesFromResource(R.xml.preferences);


        findPreference("pref_checkbox").setOnPreferenceClickListener(this);
    }


    public boolean onPreferenceClick (Preference preference)
    {
        if (preference.getKey().equals("pref_checkbox"))
        {
            // checkbox wurde geklickt
           
            return (true);
        }


        return (false);
    }
}

Beim oberen Code die "implements" Anweisung bei der Klassendeklaration beachten!

Oder so:

Preference pref_checkbox = findPreference("pref_checkbox");


pref_checkbox.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener()
    {
        public boolean onPreferenceClick (Preference preference)
        {
            // checkbox clicked


            return (true);
        }
    });

Natürlich solltest du überall noch auf null testen, denn findPreferences() gibt null zurück, falls der Identifier ungültig ist.

Zitat von Killua

thx - eine Frage - du verwendest bei dem ersten als return typ boolean....es gibt aber gar kein return...ist der return immer true ?

Oh ja, sorry. Ich hab das mehr so aus dem Kopf zusammengetippt - war mehr als Pseudo-Code gedacht. Du musst True zurückgeben, wenn dein Listener den Click behandelt, ansonsten False. False signalisiert Android, dass das Click-Event weiter nach unten durchgereicht werden muss, so dass andere Handler den Click behandeln können. True signalisiert, dass das Event behandelt wurde und nicht weiter durchgereicht werden soll.

Also musst du beim zweiten Beispiel True zurückgeben und das erste Beispiel muss so aussehen:

public boolean onPreferenceClick (Preference preference)
{
     if (preference.getKey().equals("pref_checkbox"))
     {
         // checkbox wurde geklickt
             
         return (true);
     }


     return (false);
}

Zitat von Killua

Soweit funktioniert auch alles wunderbar....sehe ich es richtig das ich keine kürzere/andere Möglichkeit habe als so vorzugehen, wenn ich über den status des buttons (ob grün oder net) entscheiden will was passieren soll....

Nicht unbedingt kürzer, aber wesentlich lesbarer/wartbarer:

public boolean onPreferenceClick (Preference preference)
{
    SharedPreferences preferences = getPreferenceManager().getSharedPreferences();


    if (preference.getKey().equals("pref_checkbox"))
    {
        String toast_message = null;


        if (preferences.getBoolean("pref_checkbox", false))
        {
            toast_message = "Aktiviert";
            Vibrator.vibrate(9223372036854775807L);
        }
        else
        {
            toast_message = "Deaktiviert";
            Vibrator.cancel();
        }


        Toast.makeText(EditPreferences.this, toast_message, Toast.LENGTH_SHORT).show();


        return (true);
    }


    return (false);
}

Aber damit wir über das gleiche Thema reden: Es geht hier um persistente Einstellungen. Es ist nicht sehr elegant die Klicks abzufragen und daraufhin eine Klasse zu manipulieren. Wenn du nämlich von einer anderen Klasse als der EditPreferences aus die Einstellungen veränderst, dann bekommt das der Vibrator nicht mit. Der sauberere Weg ist es also die Vibrator Klasse abzuleiten und sie die Einstellungen abfragen zu lassen. Dann ist es nämlich egal wo du in deinem Programm die Preferences veränderst.

Zitat

...und sehe ich es richtig das ich ebenfalls die SharedPreferences Funktion verwenden muss wenn ich zum Beispiel auf das Benutzernamen oder Passwortfeld zugreifen möchte - um den Inhalt zu ermitteln ?

Das machst du genauso wie bei der Checkbox. Nur heisst die Funktion zum abfragen des Werts dann nicht getBoolean() sondern getString() - also getString("pref_username", "");

Zitat

(Wo speichern meine Anwendung das eigentlich, also die Infos die der Benutzer eingeben hat ?)

In einer sqlite Datenbank. Die Einstellungen sind also persistent.

Zitat von Killua

Du meinst also die vibartor funktion sollte darauf lauschen wenn man so sagen kann - wenn die Einstellung geändert werden. Und nicht umgekehrt.... allein schon deswegen um dem von dir Beschrieben Problem vorzubeugen.

Das hört sich in der Tat besser an allerdings hab ich die SDK jetzt schon des öfteren gewälzt und mir ist bis dato keine methode aufgefallen die das kann....Hättest du den Namen parat ?

Das mit dem Lauschen ist nicht so einfach. Es gibt zwar einen onPreferenceChangeListener aber der informiert einen nur über Änderungen an der eigenen Instanz der Preference (soweit ich das jetzt im Kopf habe - müsste nachschauen). Der Vibrator müsste also selbstständig Änderungen erfassen. Die Implementierung hängt also davon ab was du vor hast.

Beschreib doch mal was du genau machen willst, dann können wir schauen wie eine elegantere Lösung ausschauen könnte.

Zitat

P.s.: Vielen Dank das du immr so ausführlich Antwortest, man trifft selten jemand in einem forum der einem gleich sogut hilft Vielen Dank

Kein Problem. Wir haben ja alle mal irgendwann angefangen.

Zitat von Killua

In erster Linie war es der Aufbau eines Menüs(Als zum einen das Menü, welches durch die Menütaste erscheint und darauf dann die preferences) ...in Verbindung damit, die Eingabe von Daten wie Benutzername und Passwort, welche gespeichert werden sollen....danach das aktivieren/deaktivieren des vibrators durch eine checkbox. Soweit sind wir im Prinzip....folgendes soll nun erstmal folgen...

Ok, das solltest ja jetzt soweit laufen.

Zitat

Die eingebenen Daten sollen in der Main Activity ausgegeben werden (Quasi man statet das Programm und sieht dann Ihr Benutzername ist xyz und ihr Passwort: qwert..... das Ziel davon soll eigentlich nur sein das ich quasi Prüfen kann ob die Felder ausgefüllt sind und zum anderen den Benutzer gleich beim Start darüber informieren kann das alles ok ist.)

Die Daten kannst du dir ja jetzt in deiner MainActivity direkt über die SharedPreferences besorgen und dann überprüfen ob sie Ok sind.

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences();


boolean value_check = preferences.getBoolean ("pref_checkbox", false);
String value_user = preferences.getString ("pref_username", "");
String value_pass = preferences.getString ("pref_password", "");

Die Ausgabe sollte dann auch kein Problem mehr sein.

Zitat

Danach ist es mein Ziel natürlich die eingegeben Daten Sinvoll zu verarbeien....in dem ich z.b. zu irgend einem Server Connecte auf dem z.b. eine xml datei liegt. Mein Programm soll diese xml auswerten können (nichts aufwendiges), quasi findet es die info "vibrieren" (ihr auch die antwort auf deine frage auf was ich mit der vibrieren funktion hinaus möchte) und prüft daraufhin ob er überhaupt vibrieren darf (ist in den preferences der haken grün).

Das ist dann auch der Moment in dem dein Programm checken sollte, ob das "Vibrieren"-Flag gesetzt ist - also genau bevor es vibrieren würde. Das Parsing einer XML Datei dauert aus der Sicht der CPU eh schon ewig und somit kommt es auf die minimale Verzögerung beim Auslesen des Vibrieren-Flags aus der Datenbank auch nicht mehr an. Anders würde es aussehen, wenn du alle paar Millisekunden entscheiden müsstest ob das Handy vibrieren soll oder nicht. Dann müsste man sich über Änderungen an den Preferences informieren lassen, weil andauerndes Polling der Datenbank einfach zuviel Ressourcen brauchen würde.