Android Activity – Tutorial, Typen und grundlegende Beispiele

Eine Activity ist eine einzelne, fokussierte Sache, die der Benutzer tun kann, so die offizielle Android-Dokumentation.

Der Begriff leitet sich eindeutig von dem Verb Act ab, was im Grunde genommen bedeutet, eine Aktion durchzuführen oder mit etwas zu interagieren.

Auch wenn wir eine Aktivität ohne visuelle Komponenten haben können, werden die meisten Aktivitäten erstellt, um Ansichten und Widgets zu beherbergen, mit denen Benutzer interagieren können.

Aktivitäten können sich daher vage auf den gesamten Bildschirm beziehen, mit dem der Benutzer interagieren wird.

Mit dieser Denkweise sind hier einige der Dinge, die wir mit unserer Aktivität machen können:

Nr.	Aktion	Beschreibung
1.	Neue Aktivität öffnen	Diese ersetzt dann die aktuelle Aktivität oder den Bildschirm.
2.	Schließen Sie die aktuelle "Aktivität", damit sie für uns nicht mehr sichtbar ist. Das Android-System löscht sie nicht vollständig, sondern stellt sie nur in den Hintergrund, damit Sie nicht wieder darauf zurückkommen.
3.	Drehen Sie das Gerät	Angenommen, Sie sehen sich ein Video an oder spielen ein Spiel aus dieser App und möchten es in einem anderen Layout sehen. Dieser Vorgang bewirkt, dass die "Aktivität" neu erstellt wird, um Ihren Layout-Bedürfnissen gerecht zu werden.

Wenn man Dinge wie die oben genannten tut, löst das Android-System verschiedene Lebenszyklus-Callbacks aus. Dies sind im Grunde Methoden, die ereignisgesteuert in verschiedenen Phasen des Lebenszyklus einer Aktivität ausgelöst werden. Zum Beispiel Erstellung, Anhalten, Fortsetzen, Starten, Neustarten, Stoppen usw.

Präsentationsmechanismen für eine "Aktivität

Aktivitäten" können in Android auf verschiedene Weise dargestellt werden:

No.	Mechanismus	Beschreibung
1.	Vollbildfenster :	Die häufigste Art der Darstellung einer "Aktivität", die den gesamten Bildschirm ausfüllt.
2.	Floating Windows :	Aktivitäten können als schwebende Fenster über ein Theme mit gesetztem Attribut windowIsFloating eingestellt werden.
3.	Einbettung :	Aktivitäten können auch in eine andere Aktivität eingebettet werden, indem ActivityGroup verwendet wird.

Beachten Sie jedoch, dass die Einbettung nicht mehr attraktiv ist, da die ActivityGroup mit der Einführung von Fragmenten bereits in API level 13 veraltet ist. Fragmente" und "Fragment Transaction APIs" machen dies auf eine bessere, modularere Art und Weise, wenn überhaupt, sind Fragmente im Grunde genommen Unteraktivitäten mit ihrem eigenen Lebenszyklus.

Activity Klasse Definition

Schauen wir uns auch eine programmatische Beschreibung einer Activity an.

Zunächst gehört sie zum Paket android.app:

package android.app;

Die Klasse Activity ist eine Klasse wie jede andere Klasse, aber auch auf ihre eigene Art und Weise einzigartig. Sie ist auch öffentlich, so dass sie in anderen Paketen außerhalb ihres eigenen sichtbar und nutzbar ist.

public class Activity..{}

Da sie eine Klasse ist, hat sie auch objektorientierte Eigenschaften, die andere Klassen haben, wie:

1. Die Fähigkeit, von anderen Klassen abzuleiten und von ihnen abgeleitet zu werden.
2. Die Fähigkeit, Schnittstellen zu implementieren.
3. Die Fähigkeit, eigene Methoden, Felder und innere Klassen zu haben.

Tatsächlich leitet die Klasse "Activity" von der Klasse "ContextThemeWrapper" ab.

public class Activity extends ContextThemeWrapper..{}

Der ContextThemeWrapper gibt der Klasse die Fähigkeit, das Thema zu manipulieren und zu ändern, was im verpackten Kontext ist.

Außerdem implementiert eine Activity mehrere Schnittstellen:

public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2 Window.Callback KeyEvent.Callback View.OnCreateContextMenuListener ComponentCallbacks2{}

Activity's Children und GrandChildren

Das sind die direkten Unterklassen und indirekten Unterklassen einer Activity.

Hier sind die direkten Unterklassen:

No.	Aktivität	Beschreibung
1.	FragmentActivity	Die Superklasse, die von Aktivitäten verwendet wird, die Fragmente und Loader-APIs unter Verwendung der Unterstützungsbibliothek nutzen wollen.
2.	NativeActivity	Für diejenigen, die eine bequeme Aktivität wollen, die rein in nativem Code implementiert wird.
3.	ListActivity	Eine Aktivität, die auf die Anzeige einer Liste von Elementen spezialisiert ist, die an eine Datenquelle gebunden sind.
4.	ExpandableListActivity	Eine Aktivität, die auf die Anzeige einer erweiterbaren Liste von Elementen spezialisiert ist, die an eine Datenquelle gebunden sind.
5. AliasActivity	Bietet einen Alias-ähnlichen Mechanismus für eine Aktivität. Sie tut dies, indem sie eine andere Aktivität startet und sich dann selbst beendet.
6.	AccountAuthenticatorActivity	Superklasse zur Erstellung von Aktivitäten, die AbstractAccountAuthenticator implementieren.
7.	~ActivityGroup~	Veraltet seit der Einführung von Fragmenten in API 13. Davor war es der Weg, um einen Bildschirm zu erstellen, der mehrere eingebettete Aktivitäten hat.

Nun, das sind die Kinder der Aktivität.

Schauen wir uns nun die Enkel/indirekten Unterklassen an.

Nr.	Aktivität	Haupt-Elternteil	Beschreibung
1.	AppCompatActivity	FragmentActivity	AppCompatActivity ist die Superklasse für Aktivitäten, die Aktionsleistenfunktionen nutzen wollen.
2.	~ActionBarActivity~	AppCompatActivity	Veraltet. Zuvor wurde sie verwendet, um Aktivitäten Action-Bar-Funktionen zur Verfügung zu stellen. Jetzt ist diese Rolle an AppCompatActivity übergegangen.
3. ~TabActivity~	ActivityGroup	Veraltet seit der API-Stufe 13. Davor wurde sie verwendet, um Aktivitäten mit Registerkarten zu erstellen, jetzt können Fragmente dies tun.
4.	PreferenceActivity	ListActivity	Die Superklasse, die für diejenigen verwendet wird, die den Benutzern eine Hierarchie von Einstellungen zeigen wollen.
5.	LauncherActivity	ListActivity	Diese Klasse zeigt eine Liste aller Aktivitäten an, die für einen bestimmten Zweck ausgeführt werden können.

Fähigkeiten Die Klasse Activity bietet ihre Kinder

Wir können und haben gesagt, dass Aktivitäten einzelne fokussierte Dinge darstellen, die ein Benutzer tun kann.

Wir wissen also, dass wir damit Ansichten und Widgets verwenden und rendern können, mit denen die Benutzer interagieren können.

Nun wollen wir jedoch detailliertere und spezifischere Funktionalitäten auf einer niedrigeren Ebene erkunden, die die Klasse "Activity" ihren Kindern bietet.

1. Kontext-Fähigkeiten

1. Prüfen verschiedener Berechtigungen : Zum Beispiel: checkPermission(String permission, int pid, int uid) stellt fest, ob ein bestimmter Prozess und eine bestimmte Benutzer-ID, die im System laufen, die übergebene Berechtigung haben, checkUriPermission(Uri uri, int pid, int uid, int modeFlags) stellt fest, ob ein bestimmter Prozess und eine bestimmte Benutzer-ID, die im System laufen, die Berechtigung haben, auf die übergebene Uri zuzugreifen usw.
2. Verbindung zu oder Erstellung von Anwendungsdiensten : Context kann verwendet werden, um eine Verbindung zu einem Anwendungsdienst herzustellen oder ihn bei Bedarf zu erstellen, und zwar über den Methodenaufruf bindService(Intent service, ServiceConnection conn, int flags).
   3.Andere Kontexte erstellen : Zum Beispiel createConfigurationContext(Configuration overrideConfiguration) erstellt ein neues Context-Objekt für den aktuellen Kontext, aber mit Ressourcen, die an die übergebene Konfiguration angepasst sind, createPackageContext(String packageName, int flags) gibt ein neues Context-Objekt für den angegebenen Anwendungsnamen zurück.
3. Liste zugehöriger Datenbanken und Dateien : Mit databaseList() erhalten wir ein String-Array mit den privaten Datenbanken, die mit dem Anwendungspaket dieses Contextes verbunden sind, während fileList() ein String-Array mit den privaten Dateien zurückgibt, die mit dem Anwendungspaket dieses Contextes verbunden sind.
4. Verknüpfte Datenbank und Datei löschen : Context stellt uns Methoden zur Verfügung: deleteDatabase(String name) um die SQLiteDatabase zu löschen, die mit dem Anwendungspaket dieses Contexts verbunden ist und deleteFile(String name) um die angegebene private Datei zu löschen, die mit dem Anwendungspaket dieses Contexts verbunden ist.
   6.Anwendungskontext holen : Context's getApplicationContext() gibt uns das einzelne globale Anwendungsobjekt des aktuellen Prozesses zurück.
   7. Anwendungsinformationen abrufen : Über die Funktion getApplicationInfo() können wir die vollständigen Anwendungsinformationen des aktuellen Context-Pakets abrufen.

Beispiele für schnelle Aktivitäten

1. Wie man eine Activity startet

Um eine Activity zu starten, braucht man ein Intent Objekt. Lassen Sie uns eine Methode erstellen, die für uns eine Activity starten kann. Diese Methode nimmt ein Kontext-Objekt sowie den Klassennamen der Ziel-Activity, d.h. der Activity, die wir starten wollen.

    void start(Context c, Class e){
        Intent i = new Intent(,e);
        c.startActivity(i);
        //a.finish();
    }

2. Wie man eine Activity beendet/beendet

Um eine Activity zu beenden, verwenden wir die Methode finish().

    void killIntent(Context c){
        Intent i = new Intent(c,MainActivity.class);
        c.startActivity(i);
        c.finish();
    }

3. Wie man feststellt, ob eine Activity im Vordergrund ist

Diese Beispielmethode kann für uns feststellen, ob eine Aktivität im Vordergrund ist oder nicht. Sie gibt einen booleschen Wert zurück, der auf dem Ergebnis basiert.

    public static boolean isForeground(Context context, String className) {
        if (context == null || TextUtils.isEmpty(className)) {
            returnfalse;
        }
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(1);
        if (list != null && list.size() > 0) {
            ComponentName cpn = list.get(0).topActivity;
            if (className.equals(cpn.getClassName())) {
                return true;
            }
        }
        returnfalse;
    }

    public static boolean isForeground(Activity activity) {
        return isForeground(activity, activity.getClass().getName());
    }

4. Wie man mit Backpress umgeht

Nehmen wir an, Sie wollen Backpress richtig behandeln, indem Sie dem Benutzer einen Warndialog zeigen, bevor Sie die aktuelle Aktivität beenden. In diesem Fall erstellen Sie eine handleBackPress() Methode.

    public void handleBackPress() {
        mExitDialog = true;
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style
                .AlertDialogStyle);
        builder.setTitle(R.string.leave_chat)
                .setMessage(R.string.leave_chat_desc)
                .setCancelable(false)
                .setNegativeButton(R.string.cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                mExitDialog = false;
                                dialog.cancel();
                            }
                        })
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        //showSaveHistoryDialog();
                    }
                });
        AlertDialog alert = builder.create();
        alert.show();
        alert.getWindow().setBackgroundDrawable(new ColorDrawable(getResources().getColor(R.color
                .black14)));
    }

Im obigen Fall zeigen wir dem Benutzer einen Warndialog an, wenn er auf den Zurück-Button klickt.

Android AppCompatActivity

AppCompatActivity" ist eine Klasse, die als Superklasse für Aktivitäten fungiert, die die Vorteile der Action Bar Features der Support Library nutzen wollen.

Die Voraussetzungen für die Verwendung der android.support.v7.app.ActionBar innerhalb einer Aktivität sind:

1. Sie müssen API Level 7 oder höher verwenden.
2. Dann erweitern Sie diese Klasse.
3. Setzen Sie Ihr Aktivitätsthema auf android.support.v7.appcompat.R.style#Theme_AppCompat Theme.AppCompat oder ein ähnliches Thema.

Themes werden in der AndroidManifest.xml gesetzt, z.B.

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

AppCompatActivity ist im Paket android.support.v7.app definiert:

package android.support.v7.app;

Sie leitet sich von android.support.v4.app.FragmentActivity ab:

public class AppCompatActivity extends FragmentActivity{}

Und implementiert mehrere Schnittstellen:

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {}

Hier ist ein Beispiel für eine Klasse, die von AppCompatActivity abgeleitet ist:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Einstellen des Themas AppCompatActivity

Das Thema "AppCompatActivity" kann wie andere Aktivitätsthemen entweder über androidmanifest gesetzt werden

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

oder programmatisch über die Methode setTheme() gesetzt werden:

public void setTheme(@StyleRes final int resid) {}

Wir können ein eigenes Materialthema erstellen, das von AppCompatActivity verwendet wird:

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

</resources>

Dann können wir dieses Thema auch global für die gesamte Anwendung festlegen, indem wir das Attribut android:theme="..." verwenden:

<application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">

        </activity>
    </application>

Abrufen der AppCompatActivity ActionBar

AppCompatActivity gibt uns eine Methode, um eine Referenz auf seine Aktionsleiste abzurufen:

public ActionBar getSupportActionBar(){}

Wenn sie keine hat, wird null zurückgegeben.

Verwendung von ToolBar als ActionBar in AppCompatActivity

Wir können android.support.v7.widget.Toolbar anstelle einer Actionbar verwenden. Toolbars haben den Vorteil der Flexibilität bei der Verwendung und Anpassung.

ActionBars sind normalerweise Teil des undurchsichtigen Fensterdekors der Activity. Daher werden sie vom Framework kontrolliert.

ToolBars hingegen können innerhalb des Layouts Ihrer Anwendung verwendet werden. Daher sind sie flexibel.

Nehmen wir an, wir haben eine Toolbar, die wie folgt definiert ist:

...
<android.support.v7.widget.Toolbar
            android_id="@+id/toolbar"
            android_layout_width="match_parent"
            android_layout_height="?attr/actionBarSize"
            android_background="?attr/colorPrimary"
            app_popupTheme="@style/AppTheme.PopupOverlay" />
...

in unserer activity_main.xml.

Wir können sie als Aktionsleiste verwenden, indem wir die setSupportActionBar() verwenden, wobei wir die toolbar-Referenz als Parameter übergeben.

public void setSupportActionBar(@Nullable Toolbar toolbar) {}

Beispiel:

Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

Um sie zu löschen, übergibt man null.

Android Studio - Leere Aktivität erstellen Projekt

*Wie erstellt man eine leere Activity in Android Studio?

Wie man ein Projekt in Android Studio mit der Vorlage Empty Activity erstellt. Wir sehen, wie man mit Android Studio eine leere Activity erstellt.

Empty Activity ist nur eine Vorlage für die Android-Entwicklung. Es ist die einfachste Vorlage für den Einstieg, da sie eine einzige Java-Datei und eine einzige XML-Layout-Datei erzeugt.

Hier ist der Prozess.

1. Erstellen Sie zunächst ein leeres Projekt in android studio. Gehen Sie zu Datei --> Neues Projekt.
2. Geben Sie den Anwendungsnamen ein und wählen Sie den Firmennamen.
3. Wählen Sie Minimum SDK.
4. Wählen Sie Empty activity.
5. Klicken Sie auf Fertigstellen.

Dies wird für uns ein Projekt mit den folgenden generieren:

Nr.	Name	Typ	Beschreibung
1.	activity_main.xml	XML-Layout	Wird in die MainActivity-Ansicht aufgeblasen, in der Sie Ihre Ansichten und Widgets hinzufügen.
2.	MainActivity.java	Klasse	Ihre Launcher-Aktivität

Die Aktivität wird automatisch in der Datei android_manifest.xml registriert. Android Activities sind Komponenten und müssen normalerweise als Anwendungskomponente registriert werden.
Wenn Sie Ihre manuell erstellt haben, dann registrieren Sie sie innerhalb der <application>...<application> wie folgt, wobei Sie die MainActivity durch den Namen Ihrer Aktivität ersetzen:

        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />
                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Sie können sehen, dass eine Aktion und eine Kategorie als Absichtsfilter angegeben sind. Die Kategorie macht unsere MainActivity zu einer Launcher-Aktivität. Launcher-Aktivitäten werden zuerst ausgeführt, wenn die Android-App gestartet wird.

Android Studio - Erstellen eines einfachen Aktivitätsprojekts

*Wie man ein Projekt in Android Studio mit einer Basic Activity-Vorlage erstellt.

Dies ist ein Tutorial für Anfänger, um zu sehen, wie man ein Android-Projekt basierend auf der Basisvorlage erstellt.

Hier ist der Prozess:

1. Erstellen Sie zunächst ein neues Projekt in android studio. Gehen Sie zu Datei --> Neues Projekt.
2. Geben Sie den Anwendungsnamen ein und wählen Sie den Firmennamen.
3. Wählen Sie Minimum SDK.
4. Wählen Sie Basisaktivität.
5. Klicken Sie auf Fertigstellen.

Die Basisaktivität hat bereits eine Symbolleiste und eine schwebende Aktionsschaltfläche im Layout hinzugefügt

Normalerweise werden mit dieser Option zwei Layouts erstellt:

Nr.	Name	Typ	Beschreibung
1. activity_main.xml	XML-Layout	Wird in das MainActivity-Layout aufgeblasen, das typischerweise ein Appbar-Layout mit einer Symbolleiste und einem schwebenden Aktionsbutton enthält.
2.	content_main.xml	XML-Layout	Wird in activity_main.xml eingebunden.Hier fügen Sie Ihre Ansichten und Widgets hinzu.
3.	MainActivity.java	Klasse	Hauptaktivität.

In diesem Beispiel habe ich eine einfache Aktivität verwendet.

Die Aktivität wird automatisch in der android_manifest.xml registriert. Android Activities sind Komponenten und müssen normalerweise als Anwendungskomponente registriert werden.

Wenn du deine manuell erstellt hast, dann registriere sie innerhalb der <application>...<application> wie folgt, indem du die MainActivity durch deinen Aktivitätsnamen ersetzt:

        <activity android_name=".MainActivity">

            <intent-filter>

                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

Sie können sehen, dass eine Aktion und eine Kategorie als Absichtsfilter angegeben sind. Die Kategorie macht unsere MainActivity zu einer Launcher-Aktivität. Launcher-Aktivitäten werden zuerst ausgeführt, wenn die Android-App gestartet wird.

Vorteil der Erstellung eines Basisaktivitätsprojekts

Sie können für dieses Projekt wahlweise eine leere Aktivität oder eine Basisaktivität wählen.

Die Basisaktivität hat jedoch die folgenden Vorteile:

Nr.	Vorteil
1.	Bietet uns eine vorgefertigte Symbolleiste, die uns Actionbar-Funktionen bietet und dennoch leicht anpassbar ist
2.	Bietet uns ein Appbar-Layout, das Material Design Appbar-Konzepte implementiert.
3.	3.	Bietet einen FloatinActionButton, den wir leicht verwenden können, um schnelle Aktionen zu initiieren, besonders in Beispielen wie diesen.
4.	Entkoppelt unsere benutzerdefinierten Inhaltsansichten und Widgets von den Templating-Funktionen wie der Symbolleiste.

Generierte Projektstruktur

AndroidStudio generiert für Sie ein Projekt mit Standardkonfigurationen über eine Reihe von Dateien und Verzeichnissen.

Hier sind die wichtigsten von ihnen:

No.	Datei	Hauptverantwortung
1.	build/	Ein Verzeichnis, das Ressourcen enthält, die bei der Erstellung der Anwendung kompiliert wurden, sowie die von Android-Tools generierten Klassen. Ein solches Werkzeug ist die Datei "R.java". Die Datei "R.java" enthält normalerweise die Verweise auf die Anwendungsressourcen.
2.	libs/	Für die Bibliotheken, die wir in unserem Projekt verwenden.
3.		src/main/	Hier befindet sich der Quellcode unserer Anwendung, das ist der Hauptordner, mit dem Sie arbeiten.
4.	src/main/java/	Enthält unsere Java-Klassen, die als Pakete organisiert sind.
5.		src/main/res/	Enthält unsere Projektressourcen-Ordner wie folgt.
6.	src/main/res/drawable/	Enthält unsere zeichenbaren Ressourcen.
7.	src/main/res/layout/	Enthält unsere Layout-Ressourcen.
8.	src/main/res/menu/	Enthält den XML-Code unserer Menü-Ressourcen.
9.		src/main/res/values/	Enthält unseren XML-Code für die Werte-Ressourcen, die Sätze von Name-Wert-Paaren definieren und Strings, Stile und Farben sein können.
10.	Diese Datei wird automatisch generiert, wenn wir ein Android-Projekt erstellen. Sie definiert grundlegende Informationen, die vom Android-System benötigt werden, wie Anwendungsname, Paketname, Berechtigungen, Aktivitäten, Absichten usw.
11.	build.gradle	Gradle-Skript, das zum Erstellen der Android-Anwendung verwendet wird.

Android Activities - Primitive von einer Activity an eine andere übergeben

Schauen wir uns an, wie man primitive Datentypen von einer Activity an eine andere weitergibt. Wir übergeben:

• Strings
• Ganzzahl
• Boolesch (über CheckBox)

Erste Aktivität

Zweite Aktivität

zu einer zweiten Activity und zeigen sie in der zweiten Activity an.

Gradle Dateien

Wir fügen Abhängigkeiten in der Datei build.gradle auf App-Ebene hinzu.

1. Build.gradle

Hier ist unsere App-Ebene in der build.gradle-Datei:

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        testImplementation 'junit:junit:4.12'
        implementation 'com.android.support:appcompat-v7:24.2.1'
        implementation 'com.android.support:design:24.2.1'
    }

`

LAYOUT RESOURCES

Wir haben drei xml-Layouts;

1. activity_main.xml
2. content_main.xml
3. activity_second.xml

1. activity_main.xml

• Das Vorlagenlayout für unsere Hauptaktivität.

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.design.widget.CoordinatorLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_fitsSystemWindows="true"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity">

        <android.support.design.widget.AppBarLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_theme="@style/AppTheme.AppBarOverlay">

            <android.support.v7.widget.Toolbar
                android_id="@+id/toolbar"
                android_layout_width="match_parent"
                android_layout_height="?attr/actionBarSize"
                android_background="?attr/colorPrimary"
                app_popupTheme="@style/AppTheme.PopupOverlay" />

        </android.support.design.widget.AppBarLayout>

        <include layout="@layout/content_main" />

        <android.support.design.widget.FloatingActionButton
            android_id="@+id/fab"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_gravity="bottom|end"
            android_layout_margin="@dimen/fab_margin"
            android_src="@android:drawable/ic_dialog_email" />

    </android.support.design.widget.CoordinatorLayout>

2. content_main.xml

• Hier fügen wir unsere Edittexte und Checkboxen ein.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        app_layout_behavior="@string/appbar_scrolling_view_behavior"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity"
        tools_showIn="@layout/activity_main">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <android.support.design.widget.TextInputEditText
                android_id="@+id/nameTxt"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="Name"
                android_textSize="25dp"
                android_textStyle="bold" />

            <android.support.design.widget.TextInputEditText
                android_id="@+id/txtID"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="ID"
                android_textSize="25dp"
                android_textStyle="bold" />

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExists"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
            <Button android_id="@+id/sendBtn"
                android_layout_width="wrap_content"
                android_layout_height="60dp"
                android_text="Send"
                android_clickable="true"
                android_padding="5dp"
                android_background="#009968"
                android_textColor="@android:color/white"
                android_textStyle="bold"
                android_textSize="20dp" />
        </LinearLayout>
    </RelativeLayout>

3. activity_second.xml

• Hier ist der Code für die zweite Aktivität.
• Diese Aktivität wird Daten von der Hauptaktivität empfangen und sie hier anzeigen.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context="com.tutorials.hp.primitivespassing.SecondActivity">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="NAME"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/nameTxtSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="ID"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/txtIDSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExistsSecond"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
        </LinearLayout>
    </RelativeLayout>

JAVA KLASSEN

Wir haben zwei Klassen oder zwei Aktivitäten:

1. MainActivity.java
2. SecondActivity.java

1. MainActivity-Klasse

• Unsere MainActivity.
• Wir werden Daten von dieser Aktivität an die zweite Aktivität weitergeben.

    package com.tutorials.hp.primitivespassing;

    import android.content.Intent;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.Button;
    import android.widget.CheckBox;

    public class MainActivity extends AppCompatActivity {

        //DECLARE VIEWS
        private TextInputEditText txtName, txtID;
        private CheckBox chkTechnologyExists;
        private Button sendBtn;

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

            this.initializeViews();

            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                }
            });

            //WHEN SEND BTN IS CLICKED,SEND
            sendBtn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    sendData();
                }
            });
        }

        /*
        REFERENCE VIEWS WE ARE USING
         */
        private void initializeViews() {
            txtName = (TextInputEditText) findViewById(R.id.nameTxt);
            txtID = (TextInputEditText) findViewById(R.id.txtID);
            chkTechnologyExists = (CheckBox) findViewById(R.id.techExists);
            sendBtn = (Button) findViewById(R.id.sendBtn);

        }

        /*
        SEND DATA TO SECOND ACTIVITY
         */
        private void sendData() {
            //GET PRIMITIVE VALUES TO SEND
            String name = txtName.getText().toString();
            int id = Integer.parseInt(txtID.getText().toString());
            Boolean techExists = chkTechnologyExists.isChecked();

            //PACK THEM IN AN INTENT OBJECT
            Intent i = new Intent(this, SecondActivity.class);
            i.putExtra("NAME_KEY", name);
            i.putExtra("ID_KEY", id);
            i.putExtra("TECHEXISTS_KEY", techExists);

            //LETS LEAVE OUR TXTS CLEARED
            txtName.setText("");
            txtID.setText("");

            //START SECOND ACTIVITY
            this.startActivity(i);
        }
    }

2. Klasse SecondActivity

• Unsere zweite Activity.
• Empfängt Daten von der Hauptaktivität und zeigt sie in Textviews und Checkboxen an.

    package com.tutorials.hp.primitivespassing;

    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.widget.CheckBox;
    import android.widget.Spinner;
    import android.widget.TextView;
    import android.widget.Toast;

    public class SecondActivity extends AppCompatActivity {

        //DECALRE SECOND ACTIVITY VIEWS
        TextView txtName2;
        TextView txtID2;
        CheckBox chkTechnologyExists2;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);

            //INITIALIZE THESE VIEWS
            txtName2 = (TextView) findViewById(R.id.nameTxtSecond);
            txtID2 = (TextView) findViewById(R.id.txtIDSecond);
            chkTechnologyExists2 = (CheckBox) findViewById(R.id.techExistsSecond);

            //RECEIVE DATA FROM MAIN ACTIVITY
            String name = getIntent().getStringExtra("NAME_KEY");
            int id = getIntent().getIntExtra("ID_KEY", 0);
            Boolean techExists = getIntent().getBooleanExtra("TECHEXISTS_KEY", false);

            //SHOW A TOAST
            Toast.makeText(SecondActivity.this, name, Toast.LENGTH_LONG).show();

            //SET THE DATA TO OUR LOCAL VIEWS
            txtName2.setText(name);
            txtID2.setText(String.valueOf(id));
            chkTechnologyExists2.setChecked(techExists);
        }
    }

Android ListActivity

Android ListActivity Tutorial und Beispiele.

Eine ListActivity ist eine activity, die eine Liste von Elementen durch Bindung an eine Datenquelle wie ein Array oder Cursor anzeigt. ListActivity stellt uns auch Event-Handler zur Verfügung, wenn der Benutzer ein Element auswählt.

Dies ist eine Klasse, die von der Klasse Activity abgeleitet ist. ListActivity soll verwendet werden, wenn Sie eine ListView verwenden möchten. Tatsächlich beherbergt sie ein ListView-Objekt, das an verschiedene Datenquellen gebunden werden kann, typischerweise entweder ein Array oder ein Cursor mit Abfrageergebnissen.

ListActivity API Definition

ListActivity leitet sich, wie gesagt, von der Activity-Klasse ab.

public class ListActivity extends Activity

Hier ist ihre Vererbungshierarchie:

java.lang.Object
   ↳    android.content.Context
       ↳    android.content.ContextWrapper
           ↳    android.view.ContextThemeWrapper
               ↳    android.app.Activity
                   ↳    android.app.ListActivity

ListActivity Unterklassen

Hier sind die Klassen, die sich von ListActivity ableiten:

No.	Klasse	Beschreibung
1.	LauncherActivity	Eine Klasse, die eine Liste aller Aktivitäten anzeigt, die für einen bestimmten Zweck ausgeführt werden können. Startet, wenn sie angeklickt wird.
2.	PreferenceActivity	Die Basisklasse für eine Aktivität, die dem Benutzer eine Hierarchie von Einstellungen anzeigt.

Bildschirm-Layout

ListActivity hat ein Standardlayout, das aus einer einzelnen, bildschirmfüllenden Liste in der Mitte des Bildschirms besteht. Wenn Sie es jedoch wünschen, können Sie das Bildschirmlayout anpassen, indem Sie Ihr eigenes Layout mit setContentView() in onCreate() festlegen. Um dies zu tun, MUSS Ihre eigene Ansicht ein ListView Objekt mit der id "@android:id/list" (oder list wenn es im Code ist) enthalten

Optional kann Ihre benutzerdefinierte Ansicht ein anderes Ansichtsobjekt eines beliebigen Typs enthalten, das angezeigt wird, wenn die Listenansicht leer ist. Dieser "leere Liste"-Melder muss eine id "android:id/empty" haben. Wenn eine leere Ansicht vorhanden ist, wird die Listenansicht ausgeblendet, wenn keine Daten angezeigt werden sollen.

Der folgende Code demonstriert ein (hässliches) benutzerdefiniertes Bildschirmlayout. Es hat eine Liste mit einem grünen Hintergrund und einer alternativen roten "keine Daten"-Meldung.

 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
         android_orientation="vertical"
         android_layout_width="match_parent"
         android_layout_height="match_parent"
         android_paddingLeft="8dp"
         android_paddingRight="8dp">

     <ListView android_id="@android:id/list"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#00FF00"
               android_layout_weight="1"
               android_drawSelectorOnTop="false"/>

     <TextView android_id="@android:id/empty"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#FF0000"
               android_text="No data"/>
 </LinearLayout>

Top Android ListActivity Beispiele

In diesem Abschnitt werden wir uns mehrere vollständige ListActivity-Beispiele ansehen.

1. ListActivity und OnItemClick

In diesem ersten Beispiel sehen wir uns an, wie man eine ListActivity mit Daten aus einem einfachen Array füllt. Dann sehen wir, wie man OnItemClick-Ereignisse behandelt.

APIs, die wir verwenden

Beginnen wir mit der Definition der verschiedenen APIs, die wir in diesem Beispiel verwenden werden.

(a). ListActivity

Diese Klasse gehört zu android.app. Es handelt sich um eine Aktivität, die eine Liste von Elementen anzeigt, indem sie an eine Datenquelle wie ein Array oder einen Cursor gebunden wird, und die Ereignisbehandler bereitstellt, wenn der Benutzer ein Element auswählt.

(b). Bündel

Bundle ist ein Mapping von String-Werten auf verschiedene Parcelable-Typen.

Lesen Sie hier über Bundle.

(c). Ansicht

Dies ist eine Klasse, die den Grundbaustein für Komponenten der Benutzeroberfläche darstellt. Eine View nimmt einen rechteckigen Bereich auf dem Bildschirm ein und ist für das Zeichnen und die Ereignisbehandlung zuständig.

Lesen Sie hier über Views.

(c). ArrayAdapter

Ein ArrayAdapter ist ein konkreter BaseAdapter, der durch ein Array von beliebigen Objekten unterstützt wird. Standardmäßig erwartet diese Klasse, dass die angegebene Ressource-ID eine einzelne TextView referenziert.

Lesen Sie über ArrayAdapter hier.

(d). ListView

Eine ListView ist eine Ansicht die Elemente in einer vertikal scrollenden Liste anzeigt. Die Elemente kommen von dem ListAdapter der mit dieser Ansicht verbunden ist.

Lesen Sie über ListView hier.

MyListActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;

public class MyListActivity extends ListActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_my_list);

        String[] values = new String[] { "Android", "iPhone", "WindowsMobile",
                "Blackberry", "WebOS", "Ubuntu", "Windows7", "Max OS X",
                "Linux", "OS/2" };
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,values);
        setListAdapter(adapter);

    }
    @Override
    protected  void  onListItemClick(ListView l, View v, int position, long id){

        String item = (String) getListAdapter().getItem(position);
        Toast.makeText(this, item + " selected", Toast.LENGTH_LONG).show();

    }
}

activity_my_list.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.codekul.myandroidlistactivity.MyListActivity">

    <TextView
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_text="Hello World!"
        app_layout_constraintBottom_toBottomOf="parent"
        app_layout_constraintLeft_toLeftOf="parent"
        app_layout_constraintRight_toRightOf="parent"
        app_layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

Download

Nr.	Ort	Link
1.	GitHub	Browse
2.	GitHub	Ursprünglicher Ersteller: @1sumit

2. ListActivity und ArrayAdapter Beispiel

Lassen Sie uns eine ListActivity mit CatNames füllen und dann Click-Events behandeln. Dafür brauchen wir kein Layout.

MainActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    final String[] catNamesArray = new String[] { "Рыжик", "Барсик", "Мурзик",
            "Мурка", "Васька", "Томасина", "Бобик", "Кристина", "Пушок",
            "Дымка", "Кузя", "Китти", "Барбос", "Масяня", "Симба" };
    private ArrayAdapter<String> mAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAdapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, catNamesArray);
        setListAdapter(mAdapter);

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
    }
}

Download

No.	Ort	Link
1.	GitHub	Download
2.	GitHub	Durchsuchen
2.	GitHub	Ursprünglicher Ersteller: @disiol

3. ListActivity mit AsyncTask

MainActivity.java

import android.app.ListActivity;
import android.content.Intent;
import android.os.AsyncTask;
import android.view.View;
import android.widget.Adapter;
import android.widget.ListView;

import java.util.List;

public final class AppPickerActivity extends ListActivity {

  private AsyncTask<Object,Object,List<AppInfo>> backgroundTask;

  @Override
  protected void onResume() {
    super.onResume();
    backgroundTask = new LoadPackagesAsyncTask(this);
    backgroundTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  }

  @Override
  protected void onPause() {
    AsyncTask<?,?,?> task = backgroundTask;
    if (task != null) {
      task.cancel(true);
      backgroundTask = null;
    }
    super.onPause();
  }

  @Override
  protected void onListItemClick(ListView l, View view, int position, long id) {
    Adapter adapter = getListAdapter();
    if (position >= 0 && position < adapter.getCount()) {
      String packageName = ((AppInfo) adapter.getItem(position)).getPackageName();
      Intent intent = new Intent();
      intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
      intent.putExtra("url", "market://details?id=" + packageName);
      setResult(RESULT_OK, intent);
    } else {
      setResult(RESULT_CANCELED);
    }
    finish();
  }

}

4. ListActivity - Klicken, um neue Aktivität zu öffnen

Dies ist ein ListActivity-Beispiel, in dem wir uns ansehen, wie man Elemente in einer ListActivity anzeigt. Wenn der Benutzer dann auf ein einzelnes Element klickt, wird eine neue Aktivität geöffnet.

MainActivity.java

import android.app.Activity;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    String[] names;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main);

        names = getResources().getStringArray(R.array.friends);
        setListAdapter(new ArrayAdapter<String>(this, R.layout.friend_item, names));

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        Intent in = new Intent(this, SecondActivity.class);

        in.putExtra("message", getString(R.string.show_greetings)+ " " + names[(int) id] + "!" );

        startActivity(in);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

SecondActivity.java

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        Intent in = getIntent();

        TextView txtName = (TextView) findViewById(R.id.txtGreetingName);
        txtName.setText(in.getStringExtra("message"));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_second, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

activity_main.xml

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context=".MainActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="54dp" />

</RelativeLayout>

activity_second.xml

<RelativeLayout
     android_layout_width="match_parent"
    android_layout_height="match_parent" android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context="com.example.paulorogerio.friendgreeting.SecondActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_gravity="center_vertical|center_horizontal"
        android_id="@+id/txtGreetingName"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="55dp" />

</RelativeLayout>

friend_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView
    android_layout_width="match_parent" android_layout_height="match_parent"
    android_text="Friend Name"
    android_gravity="center_vertical|center_horizontal"
    android_textSize="24sp"
    android_padding="20dp">

</TextView>

Download

Nr.	Ort	Link
1.	GitHub	Download
2.	GitHub	Durchsuchen
2.	GitHub	Ursprünglicher Ersteller: @paulonova

5. ListActivity - Aus in Assets gespeichertem XML auffüllen

In diesem Beispiel sehen wir uns an, wie wir XmlPullParser verwenden, um ein XML-Dokument zu parsen, das im Assets-Verzeichnis unserer Anwendung gespeichert ist.
Wir werden dann die geparsten XML-Ergebnisse, die Bilder und Text enthalten, in unserer ListActivity anzeigen.

Wir werden aus unserem XML-Dokument Titel, Link und Bilder in unsere ListView laden. Wir öffnen unser XML aus dem Assets-Ordner in einen InputStream. Dann werden wir eine "ParseXML()"-Methode haben, die unser XML mit dem XmlPullParser parsen wird.

Die ImagesAdapter Klasse wird die Bilder und den Text aus dem XML in eine benutzerdefinierte ListView anpassen. Sie wird den ArrayAdapter als Basisadapterklasse verwenden.

ParseXML.java

Diese ParseXML ist die Hauptaktivität.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.widget.ListView;

public class ParseXML extends Activity {
    InputStream xmlStream;
    ArrayList<ItemData> list;
    XMLHandler handler;
    ListView listView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parse_xml);
        try {
            xmlStream = this.getAssets().open("ItemXML.xml");
            ParseXML();
            list = handler.getItemList();
            LoadImagesFromUrl();
            ImageAdapter adapter = new ImageAdapter(ParseXML.this, R.layout.imagelist, list);
            listView = (ListView) findViewById(R.id.imageList);
            listView.setAdapter(adapter);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_parse_xml, menu);
        return true;
    }

    public void ParseXML(){

        try {
            SAXParserFactory spf = SAXParserFactory.newInstance();
            SAXParser sp = spf.newSAXParser();
            XMLReader reader = sp.getXMLReader();
            handler = new XMLHandler();
            reader.setContentHandler(handler);
            reader.parse(new InputSource(xmlStream));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void LoadImagesFromUrl(){
        for (int i=0; i<list.size();i++){
            LoadChart loader = new LoadChart(ParseXML.this, list.get(i).link);
            loader.execute();
            list.get(i).bitmap = loader.getBitmap();
        }
    }
}

ItemData.java

Dies ist die Modellklasse und stellt ein einzelnes XML-Element dar, das unser ListView-Element enthalten wird. Wir werden einen Titel, einen Link und eine Bitmap haben.

package com.example.parsexml;

import android.graphics.Bitmap;

public class ItemData {
    String title;
    String link;
    Bitmap bitmap;
    public Bitmap getBitmap() {
        return bitmap;
    }
    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getLink() {
        return link;
    }
    public void setLink(String link) {
        this.link = link;
    }

}

ImageAdapter.java

Dies ist die benutzerdefinierte Adapterklasse, die vom "ArrayAdapter" abgeleitet ist. Sie verwendet das ViewHolder-Muster, um die zu recycelnden Views zu halten. Dieser ViewHolder ist nur eine einfache Klasse, um TextView und ImageView Widgets für das Recycling zu halten, anstatt sie jedes Mal aufzublasen, wenn die getView() Methode aufgerufen wird.

package com.example.parsexml;

import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class ImageAdapter extends ArrayAdapter{
    ViewHolder holder;
    Context ctx;
    List<ItemData> list;
    LoadChart loader;
    public ImageAdapter(Context context, int textViewResourceId,
            List<ItemData> objects) {
        super(context, textViewResourceId, objects);
        ctx = context;
        list = objects;

        // TODO Auto-generated constructor stub
    }
    private class ViewHolder{
        TextView titleView;
        ImageView img;
    }
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        if(convertView == null){
            LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(ctx.LAYOUT_INFLATER_SERVICE);
            convertView = inflater.inflate(R.layout.imagelist, null);
            holder = new ViewHolder();
            holder.img = (ImageView) convertView.findViewById(R.id.linkimage);
            holder.titleView = (TextView) convertView.findViewById(R.id.title);

            convertView.setTag(holder);

        }
        else{
            holder = (ViewHolder) convertView.getTag();
        }
        holder.titleView.setText(list.get(position).title);
        loader = new LoadChart(ctx, holder.img, list.get(position).link);
        loader.execute();

        return convertView;

    }

}

XMLHandler.java

Diese Klasse wird von der Klasse org.xml.sax.helpers.DefaultHandler abgeleitet. DefaultHandler ist die Standard-Basisklasse für SAX2-Ereignishandler. In dieser Klasse überschreiben wir mehrere Methoden wie startElement(), endElement() und characters().

package com.example.parsexml;

import java.util.ArrayList;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XMLHandler extends DefaultHandler{
    private ArrayList<ItemData> itemList = new ArrayList<ItemData>();
    String value = "";
    ItemData item = null;
    Boolean flag = false;

    public ArrayList<ItemData> getItemList() {
        return itemList;
    }

    public void setItemList(ArrayList<ItemData> itemList) {
        this.itemList = itemList;
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        if(flag){
            value = new String(ch, start, length);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        flag = false;

        if(localName.equalsIgnoreCase("title")){
            item.setTitle(value);
        }
        if(localName.equalsIgnoreCase("link")){
            item.setLink(value);
        }
        if(localName.equalsIgnoreCase("item")){
            itemList.add(item);
        }

    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        flag = true;
        value = "";
        if(localName.equalsIgnoreCase("item")){
            item = new ItemData();

        }
    }

}

LoadChart.java

Diese Klasse wird von der abstrakten asynctask-Klasse abgeleitet. Damit können wir unser XML in einem separaten Thread laden.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

import android.app.ProgressDialog;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.ImageView;

public class LoadChart extends AsyncTask<Void, Void, Bitmap> {
    private ImageView img;
    private Context con;
    static String urlString ;
    Bitmap bitmap= null;

    public Bitmap getBitmap() {
        return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }

    public LoadChart(Context context, ImageView img1, String url) {
        this.img = img1;
        this.con = context;
        urlString = url;
    }

    public LoadChart(Context context, String url) {
        this.urlString = url;
        this.con = context;
    }

    @Override
    protected void onPreExecute() {

        super.onPreExecute();
    }

    @Override
    protected Bitmap doInBackground(Void... params) {

        Bitmap bitmap = DownloadImage();

        return bitmap;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        this.bitmap = bitmap;
        //img.setImageBitmap(bitmap);

    }

    private static InputStream OpenHttpConnection(String urlString)
            throws IOException {

        Log.d("palval", "OpenHttpConnection");
        InputStream in = null;
        int response = -1;

        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();

        if (!(conn instanceof HttpURLConnection))
            throw new IOException("Not an HTTP connection");

        try {
            HttpURLConnection httpConn = (HttpURLConnection) conn;
            httpConn.setAllowUserInteraction(false);
            httpConn.setInstanceFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.connect();

            response = httpConn.getResponseCode();

            if (response == HttpURLConnection.HTTP_OK) {
                in = httpConn.getInputStream();
            }

            String res = Integer.toString(response);
        } catch (Exception ex) {
            throw new IOException("Error connecting");
        }
        return in;
    }

    public static Bitmap DownloadImage() {
        Log.d("palval", "DownloadImage");
        Bitmap bitmap = null;
        InputStream in = null;
        try {

             //in = OpenHttpConnection("https://chart.googleapis.com/chart?chs=440x220&chd=t:60,40&cht=p3&chl=Hello|World");
            in = OpenHttpConnection(urlString);
            bitmap = BitmapFactory.decodeStream(in);
            in.close();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return bitmap;
    }

}

Download

Nr.	Ort	Link
1.	GitHub	Herunterladen
2.	GitHub	Durchsuchen
2.	GitHub	Original Creator: @bansal2211

Android ListActivity - Mit Bildern, Text und OnItemClick ArrayAdapter

Android ListActivity Bilder Text

Dies ist ein android benutzerdefinierte listview tutorial.How zu zeigen, Bilder und Text in einem listview.We sind mit arrayadapter als unsere Adapter der Wahl.We sehen auch, wie man benutzerdefinierte listview itemclicks behandeln.

Abschnitt 1 : CustomAdapter Klasse

Dies ist unsere CustomAdapter Klasse. Sie wird die Unterklasse android.widget.ArrayAdapter. Lesen Sie mehr über ArrayAdapter hier.

Das ist unsere Adapterklasse.

    package com.tutorials.customlistviewarrayadapter;

    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.ArrayAdapter;
    import android.widget.ImageView;
    import android.widget.TextView;

    public class CustomAdapter extends ArrayAdapter<String>{

      final Context c;
      String[] values;

      //CONSTRUCTOR
      public CustomAdapter(Context context, String[] values) {
        super(context,R.layout.activity_main, values);

        this.c=context;
        this.values=values;

      }

      @Override
      public View getView(int position, View convertView, ViewGroup parent) {

        LayoutInflater inflator=(LayoutInflater) c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        //INFLATE OUR XML LAYOUT TO ROW
        View row=inflator.inflate(R.layout.activity_main, parent,false);

        //DECLARE FIELDS CONTAINED IN OUR LAYOUR
        TextView tv=(TextView) row.findViewById(R.id.textView1);
        ImageView img=(ImageView) row.findViewById(R.id.imageView1);

        //GET AN ITEM FROM ARRAY
        String item=values[position];

        //DYNAMICALLY SET TEXT AND IMAGES DEPENDING ON ITEM IN ARRAY
        if(item.equals("android"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.android);
        }else if(item.equals("java"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.java);
        }else if(item.equals("c#"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.csharp);
        }else if(item.equals("mysql"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.mysql);
        }else if(item.equals("access"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.access);
        }else if(item.equals("excel"))
        {
          tv.setText(item+" Microsoft");
          img.setImageResource(R.drawable.excel);
        }

        return row;
      }

    }

Abschnitt 2 : MainActivity

Unsere Hauptaktivität. Sie ist eine Unterklasse der Klasse ListActivity.

package com.tutorials.customlistviewarrayadapter;

import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ListView;
import android.widget.Toast;

public class MainActivity extends ListActivity {

  String[] languages={"android","java","c#","mysql","access","excel"};

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
      //  setContentView(R.layout.activity_main);

        CustomAdapter adapter=new CustomAdapter(this, languages);
        setListAdapter(adapter);
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        // TODO Auto-generated method stub
        super.onListItemClick(l, v, position, id);

        String item=(String) getListAdapter().getItem(position);

        Toast.makeText(getApplicationContext(),"Welcome to "+ item+" Programming language", Toast.LENGTH_SHORT).show();
    }
}

Abschnitt 3 : Layouts

ActivityMain.xml

Das Layout für unsere Hauptaktivität.

    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context=".MainActivity" >

        <ImageView
            android_id="@+id/imageView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentLeft="true"
            android_layout_alignParentTop="true"
            android_layout_marginLeft="16dp"
            android_layout_marginTop="17dp"
            android_src="@drawable/ic_launcher" />

        <TextView
            android_id="@+id/textView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignBottom="@+id/imageView1"
            android_layout_alignParentRight="true"
            android_layout_alignTop="@+id/imageView1"
            android_layout_marginLeft="16dp"
            android_layout_toRightOf="@+id/imageView1"
            android_text="TextView" />

    </RelativeLayout>

Guten Tag!