Android SDK: Verwendung von Fragmenten

German (Deutsch) translation by Alex Grigorovich (you can also view the original English article)

Der Begriff der Fragmente wurde in Android 3.0, API Level 11, eingeführt. Seitdem wurden in der Android-Community sechs wichtige Plattformversionen veröffentlicht. Dennoch steht mehr als der Hälfte der aktiven Android-Geräte diese Funktion nicht nativ zur Verfügung. Entwickler müssen stattdessen die Android Support-Bibliothek verwenden, wenn sie Fragmente mit diesen Geräten verwenden möchten. In diesem Lernprogramm erfahren Sie, wie Sie mithilfe der Android-Support-Bibliothek eine grundlegende fragmentbasierte App erstellen.

Schritt 0: Erste Schritte

Dieses Tutorial richtet sich an Android-Entwickler, die die überwiegende Mehrheit der derzeit in den Händen der Benutzer befindlichen Android-Geräte ansprechen möchten und die Fragment-API nutzen möchten, die die Unterstützung für eine Vielzahl von Bildschirmgrößen vereinfacht. Sie sollten mit Java und Eclipse vertraut sein und mit den Grundlagen von Android vertraut sein.

Dieses Tutorial ist auch für diejenigen gedacht, die detailliertere Anweisungen benötigen als das, was unser anderes Fragment-Tutorial gegeben hat, oder für diejenigen, die eine neue Sicht auf Fragmente benötigen.

Um die Auswirkungen und Unterschiede eines reaktionsschnellen, gut gestalteten Fragmentbildschirmdesigns vollständig zu erkennen, benötigen Sie zwei Geräte (oder konfigurierte Emulatoren): eines mit einem normalen Bildschirm in Telefongröße und eines mit einem Bildschirm in Tablet-Größe.

Beachten Sie, dass dieser Code auf dem Best-Practices-Code basiert, der vom Assistenten für neue Android-Anwendungen in Eclipse erstellt wurde. Das Projekt kann beim Google Code Hosting heruntergeladen und durchsucht werden, ebenso wie die installierbare Binärdatei.

Schritt 1: Klassische Zwei-Fenster-Ansicht

Das Beispiel hier ist das klassische Fragmentbeispiel, das auch als "Master-Detail" -Fluss bezeichnet wird. Wir beginnen mit einer Liste von „Dingen“ (Gegenstände, es können Lieder, Filme, Haustiere usw. sein) und wenn ein „Ding“ angeklickt wird, zeigen wir die Details für dieses bestimmte „Ding“ an. Wenn die Bildschirmgröße des Geräts sowohl die Liste als auch die Details anzeigen kann, werden zwei Fragmente verwendet. Andernfalls wird nur eine verwendet, und der Benutzer muss auf klicken, um einen Drilldown zu den Details durchzuführen.

Hier ist eine Abbildung, die die typische Bildschirmorganisation vor Fragmenten zeigt oder wenn der Bildschirm nicht groß genug ist, um so viele Informationen nebeneinander zu verarbeiten:

Und hier ist das Bildschirmdesign, wenn es mit Fragmenten fertig ist, wie es auf einem großen oder breiten Gerät wie einem Tablet angezeigt wird:

Fragmente machen Aktivitäten nicht überflüssig. Tatsächlich benötigen Sie noch zwei Aktivitäten: Eine Aktivität behandelt den Fall, in dem beide Fragmente angezeigt werden (Zwei-Fenster-Modus), und eine andere die Detailansicht, wenn nur die Liste auf dem ersten Bildschirm angezeigt wurde, da der Gerätebildschirm angezeigt wird Größe war klein. Durch die Verwendung entsprechend organisierter Ressourcen wird die erste Aktivität dynamisch an die Bildschirmbreite angepasst. Intern muss diese Aktivität wissen, ob sie sich im Zwei-Fenster-Modus befindet oder nicht, damit sie das Detailfragment korrekt platzieren oder die Detailaktivität nach Bedarf erzeugen kann, die nur das Detailfragment enthält.

Zur Vereinfachung: Sie müssen zwei Aktivitätsklassen und zwei Fragmentklassen implementieren, um diese Fälle zu behandeln. Die Aktivitätsklassen sind ziemlich einfach, da sie nur das richtige Fragment oder die richtigen Fragmente anzeigen und den App-Fluss steuern. In unserem Beispiel verwenden wir die folgenden Aktivitätsklassen: die Hauptklasse CircleListActivity, die manchmal verwendete Detailklasse CircleDetailActivity. Wir haben auch die zwei Fragmentklassen, die tatsächlich Layout und Zeichnung ausführen: CircleListFragment und CircleDetailFragment. Ja, wir reden über Kreise. Kreise sind nur Dinge. Sie müssen sich nicht mit dem „Ding“ befassen, das wir ausgewählt haben.

Schritt 2: Erstellen der primären Aktivität

Die Hauptaktivität CircleListActivity ist der Ausgangspunkt für das Laden eines oder beider Fragmente für den Bildschirm.

 
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;

public class CircleListActivity extends FragmentActivity {
	private boolean mTwoPane;

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

		if (findViewById(R.id.circle_detail_container) != null) {

			mTwoPane = true;

			((CircleListFragment) getSupportFragmentManager().findFragmentById(
					R.id.circle_list)).setActivateOnItemClick(true);
		}

	}

}

Beachten Sie, dass wir den Android Support FragmentManager verwenden, nicht den in Android 3.0 eingeführten.

Die Aktivitätsklasse macht jedoch sehr wenig. Die gesamte Hauptlogik erfolgt automatisch, da das Android-Betriebssystem beim Aufruf der Methode setContentView() die richtige Layoutressourcenversion für das Gerät lädt. Dies bedeutet, dass Sie Ihre Aufmerksamkeit nur auf die betreffenden Ressourcen konzentrieren müssen. Wie wählt die Ressource ein oder zwei Fragmente richtig aus?

Schritt 3: Definieren der Layouts für die Bildschirme

Pop Quiz: Wie viele Layouts benötigen wir, um beide Fragmente anzuzeigen?

Antwort: 3, aber das beinhaltet nicht das Layout jedes Fragments.

Wir benötigen ein Layout, das sowohl das Listenfragment als auch das Detailfragment anzeigt. Wir brauchen ein anderes Layout, das nur das Listenfragment zeigt. Schließlich benötigen wir ein drittes Layout, das nur das Detailfragment zeigt.

Layouts können ein Fragment-Tag verwenden, um ein bestimmtes zu ladendes Fragment anzugeben. Dies funktioniert jedoch nur für feste Fragmente. Für dynamische Fragmente, z. B. das Detailfragment, das je nach Auswahl unterschiedliche Informationen anzeigt, verwenden wir eine Containeransicht, um anzugeben, wohin das Fragment im Layout gehen soll. Der am häufigsten verwendete Container ist ein FrameLayout, da es nur ein untergeordnetes Element enthält und dann an einer beliebigen Stelle im enthaltenen Layout als Block positioniert werden kann.

Zu Beginn erstellen wir die beiden Layouts für einzelne Fragmente.

Zunächst das Layout, in dem nur das Listenfragment angezeigt wird:

<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/circle_list"
    android:name="com.mamlambo.circlesfragmentexample.CircleListFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginLeft="16dp"
    android:layout_marginRight="16dp"
/>

Nun das Layout, das nur das Detailfragment anzeigt:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/circle_detail_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
 />

Wenn diese ziemlich einfach aussehen, liegt es daran, dass sie es sind. Um es noch einmal zu wiederholen: Dies sind die Layouts, die bestimmen, wo sich die Fragmente befinden, und nicht, wie die Fragmente aussehen.

Kombinieren wir sie abschließend zu einem Layout, in dem beide Fragmente angezeigt werden:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginLeft="16dp"
    android:layout_marginRight="16dp"
    android:orientation="horizontal"
    android:showDividers="middle"
    >

    <fragment
        android:id="@+id/circle_list"
        android:name="com.mamlambo.circlesfragmentexample.CircleListFragment"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="1"/>

    <FrameLayout
        android:id="@+id/circle_detail_container"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="3" />

</LinearLayout>

Nachdem Sie nun wissen, wie die Layouts aussehen, fragen Sie sich möglicherweise immer noch, wie das richtige Programm programmgesteuert ausgewählt wird.

Schritt 4: Organisieren der Layouts für verschiedene Szenarien

Sie wissen, dass das Android-Betriebssystem basierend auf den aktuellen Geräteeigenschaften geeignete Ressourcen auswählt. Auf den ersten Blick können Sie also Layouts in Ordnern wie Layout-Land, Layout-Groß, Layout-Klein usw. platzieren. Sie würden das Layout der einzelnen Listenfragmente genauso benennen wie das Layout der doppelten Fragmente und beide in verschiedenen Ordnern ablegen. Dies könnte sogar funktionieren, aber diese Methode ist schwer zu warten, da mehrere verschiedene Dateien für mehrere identische Layouts vorhanden sind.

Stattdessen können Sie Verweise verwenden, um aus einem bestimmten Ressourcenordner auf ein bestimmtes Element in Android zu verweisen. Es ist am besten, ein Beispiel dafür zu sehen. Wir werden unsere drei aktivitätsbasierten Layouts benennen (im Gegensatz zu den einzelnen darin enthaltenen Fragmenten): activity_circle_detail, activity_circle_list und activity_circle_twopane. Dann legen wir alle drei in den Standardlayoutordner. Sie haben bereits im Code aus Schritt 2 gesehen, dass wir immer nur das Layout activity_circle_list laden. Oder wir?

Fügen wir nun einige Referenzen hinzu. Ein guter Weg, um festzustellen, ob der Bildschirm für zwei nebeneinander liegende Fenster geeignet ist, ist die Breite in dp-Einheiten. Angenommen, unser Layout mit zwei Fenstern erfordert mindestens 850 dp Bildschirmbreite. Erstellen wir einen Ordner mit dem Namen values-w850dp. Dies sollte 7-Zoll-Tablets mit hoher Dichte und 10-Zoll-Tablets mittlerer Dichte im Querformat abdecken, enthält jedoch keine xddpi-Telefone und schließt den Hochformatmodus auf den meisten Geräten aus, mit Ausnahme einiger Bildschirme mit sehr hoher Auflösung. Erstellen Sie in diesem Ordner eine Datei mit dem Namen refs.xml und platzieren Sie Folgendes darin:

1	<resources>
2	<item name="activity_circle_list" type="layout">@layout/activity_circle_twopane</item>
3	</resources>

Wie funktioniert das? Wenn die Breite 850 dp oder mehr beträgt, wird diese Referenz zum Laden des Layouts verwendet. Das bedeutet, dass das Layout mit zwei Fenstern verwendet wird, anstatt dass die einzelnen Fenster separat angezeigt werden. Da dieses Ressourcenqualifikationsmerkmal (Konvention zur Benennung von Ordnern) erst auf API-Ebene 13 eingeführt wurde, möchten wir dieselbe Referenz auch in ein anderes geeignetes Qualifikationsmerkmal für Ordner aufnehmen, das es schon viel länger gibt, z. B. values-xlarge-land. Extra groß ist definiert als mindestens 960 dp mal 720 dp, daher müssen wir auch sicherstellen, dass es nur im Querformat angezeigt wird, indem wir das Land-Qualifikationsmerkmal einschließen.

Nachdem die Layouts organisiert sind, ist es Zeit, uns wieder auf den Java-Code zu konzentrieren. Während beim ersten Start der Listenaktivität das richtige Layout auf dem Bildschirm angezeigt wird, was passiert, wenn auf eines der Listenelemente getippt wird?

Schritt 5: Definieren des Listenfragments

Das Listenfragment behandelt die Anzeige unserer Reihe von Dingen (in diesem Fall Kreise). Es ist nicht anders als eine ListActivity, da es eine gewisse Handhabung von Routinelistenaufgaben bietet, um Ihre eigene Codierung zu vereinfachen. Die Liste muss alle Kreise aus der Datenquelle enthalten (in diesem Fall eine Scheindatenquelle) und Taps auf bestimmte Elemente verarbeiten, um die Details anzuzeigen. Da ein Fragment jedoch keine Aktivität ist, sollte es Ereignisse weitergeben, die möglicherweise den Bildschirm in die steuernde Aktivitätsklasse ändern. Durch Tippen im Modus mit zwei Fenstern wird ein Fragment im anderen Bereich auf demselben Bildschirm geladen, während durch Tippen im Modus mit einem Fenster eine neue Aktivität mit dem Detailfragment geladen werden sollte. Das Fragment kennt diese Konfigurationsdetails jedoch nicht und sollte es auch nicht wissen.

Sie müssen jedoch eine konsistente Methode erstellen, um diese Informationen an die enthaltende oder steuernde Aktivität weiterzugeben, die diese Details kennt und kennen sollte. Am häufigsten wird diese Kommunikation über eine im Fragment definierte Schnittstellenklasse verwaltet, die von jeder Aktivität implementiert werden muss, die sie verwendet - eine typische Methode zum Ausführen von Rückrufen.

Hier finden Sie den gesamten Code für die CircleListFragment-Klasse, einschließlich eines sicheren Rückrufmechanismus und der Tap-Behandlung, die die Rückrufmethode aufruft, um die Workflow-Behandlung an die steuernde Aktivität zu übergeben.

import android.app.Activity;
import android.os.Bundle;
import android.support.v4.app.ListFragment;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

import com.mamlambo.circlesfragmentexample.dummy.DummyContent;

public class CircleListFragment extends ListFragment {

	private static final String STATE_ACTIVATED_POSITION = "activated_position";
	private Callbacks mCallbacks = sDummyCallbacks;
	private int mActivatedPosition = ListView.INVALID_POSITION;
	public interface Callbacks {
		public void onItemSelected(String id);
	}

	private static Callbacks sDummyCallbacks = new Callbacks() {
		@Override
		public void onItemSelected(String id) {
		}
	};

	public CircleListFragment() {
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		setListAdapter(new ArrayAdapter<DummyContent.DummyItem>(getActivity(),
				android.R.layout.simple_list_item_activated_1,
				android.R.id.text1, DummyContent.ITEMS));
	}

	@Override
	public void onViewCreated(View view, Bundle savedInstanceState) {
		super.onViewCreated(view, savedInstanceState);

		if (savedInstanceState != null
				&amp;&amp; savedInstanceState.containsKey(STATE_ACTIVATED_POSITION)) {
			setActivatedPosition(savedInstanceState
					.getInt(STATE_ACTIVATED_POSITION));
		}
	}

	@Override
	public void onAttach(Activity activity) {
		super.onAttach(activity);

		if (!(activity instanceof Callbacks)) {
			throw new IllegalStateException(
					"Activity must implement fragment's callbacks.");
		}

		mCallbacks = (Callbacks) activity;
	}

	@Override
	public void onDetach() {
		super.onDetach();

		mCallbacks = sDummyCallbacks;
	}

	@Override
	public void onListItemClick(ListView listView, View view, int position,
			long id) {
		super.onListItemClick(listView, view, position, id);

		mCallbacks.onItemSelected(DummyContent.ITEMS.get(position).id);
	}

	@Override
	public void onSaveInstanceState(Bundle outState) {
		super.onSaveInstanceState(outState);
		if (mActivatedPosition != ListView.INVALID_POSITION) {
			outState.putInt(STATE_ACTIVATED_POSITION, mActivatedPosition);
		}
	}

	public void setActivateOnItemClick(boolean activateOnItemClick) {
		getListView().setChoiceMode(
				activateOnItemClick ? ListView.CHOICE_MODE_SINGLE
						: ListView.CHOICE_MODE_NONE);
	}

	private void setActivatedPosition(int position) {
		if (position == ListView.INVALID_POSITION) {
			getListView().setItemChecked(mActivatedPosition, false);
		} else {
			getListView().setItemChecked(position, true);
		}

		mActivatedPosition = position;
	}
}

Abgesehen von der zuvor beschriebenen Funktionalität gibt es eine ListView-Verwaltung, sodass das angeklickte Listenelement im Dual-Pane-Modus als ausgewählt angezeigt wird, sowie eine grundlegende Verwaltung des Fragmentlebenszyklus. Nach wie vor verwenden wir die Support Fragment-Version, damit wir mit älteren Geräten abwärtskompatibel sind. Stellen Sie sicher, dass Sie das richtige Paket in die Support-Bibliothek importieren (import android.support.v4.app.ListFragment).

Jetzt müssen wir zur steuernden Aktivitätsklasse zurückkehren, damit sie den Rückruf behandelt.

Schritt 6: Aktualisieren der primären Aktivität

Fügen Sie die Rückrufunterstützung zur primären Aktivitätsklasse CircleListActivity hinzu, indem Sie die zuvor erstellte Schnittstelle CircleListFragment.Callbacks implementieren. Implementieren Sie dann die onItemSelected() -Methode, um das App-Verhalten basierend darauf zu verzweigen, ob das Gerät den Zwei-Fenster-Modus verarbeiten kann oder nicht. Hier ist die vollständig aktualisierte Klasse:

import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;

public class CircleListActivity extends FragmentActivity implements
		CircleListFragment.Callbacks {

	private boolean mTwoPane;

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

		if (findViewById(R.id.circle_detail_container) != null) {
			mTwoPane = true;

			((CircleListFragment) getSupportFragmentManager().findFragmentById(
					R.id.circle_list)).setActivateOnItemClick(true);
		}

		// TODO: If exposing deep links into your app, handle intents here.
	}

	@Override
	public void onItemSelected(String id) {
		if (mTwoPane) {
			Bundle arguments = new Bundle();
			arguments.putString(CircleDetailFragment.ARG_ITEM_ID, id);
			CircleDetailFragment fragment = new CircleDetailFragment();
			fragment.setArguments(arguments);
			getSupportFragmentManager().beginTransaction()
					.replace(R.id.circle_detail_container, fragment).commit();

		} else {
			Intent detailIntent = new Intent(this, CircleDetailActivity.class);
			detailIntent.putExtra(CircleDetailFragment.ARG_ITEM_ID, id);
			startActivity(detailIntent);
		}
	}
}

Mithilfe des Flags, um festzustellen, ob die Doppelfensteransicht angezeigt wird, startet die onItemSelected() -Methode entweder eine neue Aktivität oder ersetzt jedes aktuelle Fragment in R.id.circle_detail_container durch eine neue Instanz der CircleDetailFragment-Klasse. Für diese Art von Design wird wenig mehr benötigt. Der Bezeichner, auf welchen Kreis der Benutzer getippt hat, wird entweder über Argumente an die neue Fragmentinstanz oder an die neue Aktivität übergeben, wo der Bezeichner ebenfalls in Argumente umgewandelt wird.

Zu diesem Zeitpunkt müssen wir sowohl die CircleDetailActivity-Klasse für den Einzelbereich als auch die CircleDetailFragment-Klasse implementieren.

Schritt 7: Definieren der Einzelfenster-Detailaktivität

Erinnern Sie sich an die Einfachheit des Layouts für diese Aktivitätsklasse. Das Layout ist einfach ein Platzhalter für die Detailfragmentklasse. Alles, was diese Aktivität tun muss, ist, den Bezeichner an ihn zu übergeben, ihn in ein Fragment-Argument umzuwandeln und das Fragment dann dem Container hinzuzufügen.

package com.mamlambo.circlesfragmentexample;

import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
public class CircleDetailActivity extends FragmentActivity {

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

				if (savedInstanceState == null) {
			Bundle arguments = new Bundle();
			arguments.putString(CircleDetailFragment.ARG_ITEM_ID, getIntent()
					.getStringExtra(CircleDetailFragment.ARG_ITEM_ID));
			CircleDetailFragment fragment = new CircleDetailFragment();
			fragment.setArguments(arguments);
			getSupportFragmentManager().beginTransaction()
					.add(R.id.circle_detail_container, fragment).commit();
		}
	}
}

Wenn es einfach klang, können Sie jetzt sehen, dass es ist. Das letzte Stück, das wir erreichen müssen, ist das Detailfragment selbst.

Schritt 8: Zeigen Sie das Detailfragment an

Die Detailfragmentklasse muss sehen, welche Kreisdaten geladen und angezeigt werden sollen. Dann müssen diese Daten geladen und angezeigt werden. Die Klasse lädt ein Layout. Das Layoutdesign kann allgemein gehalten sein, sollte jedoch die Tatsache berücksichtigen, dass es als Fragment Vollbild sein kann oder nicht. Mit anderen Worten, machen Sie wie üblich keine Annahmen über die Bildschirmgröße des Geräts. Natürlich können Sie auch wie gewohnt mehrere Layouts basierend auf Ressourcenqualifizierern erstellen. Beachten Sie, dass diese basierend auf den allgemeinen Eigenschaften des Gerätebildschirms und nicht basierend auf den Eigenschaften des Anzeigebereichs (Fenstermodi) geladen werden.

In diesem Beispiel gibt es keine weitere Navigation, sodass kein Rückruf erforderlich ist, wie dies beim Listenfragment der Fall war.

Hier ist ohne weiteres der gesamte Code für die CircleDetailFragment-Klasse:

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;

import com.mamlambo.circlesfragmentexample.dummy.DummyContent;

public class CircleDetailFragment extends Fragment {
	public static final String ARG_ITEM_ID = "item_id";

	private DummyContent.DummyItem mItem;
	public CircleDetailFragment() {
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		if (getArguments().containsKey(ARG_ITEM_ID)) {
			mItem = DummyContent.ITEM_MAP.get(getArguments().getString(
					ARG_ITEM_ID));
		}
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState) {
		View rootView = inflater.inflate(R.layout.fragment_circle_detail,
				container, false);

		if (mItem != null) {
			((TextView) rootView.findViewById(R.id.circle_detail))
					.setText(mItem.content);
			((ImageView) rootView.findViewById(R.id.circle_view))
					.setImageResource(mItem.resourceId);
		}

		return rootView;
	}
}

Obwohl der gesamte Code im Wesentlichen mit einem Nicht-Support-Fragment identisch ist, beachten Sie den richtigen Import für android.support.v4.app.Fragment, um sicherzustellen, dass Sie die richtige Android-Support-Klasse verwenden.

Schritt 9: Aktualisieren der Android-Manifestdatei für Fragmente

Jetzt müssen wir die Fragmente zur Manifestdatei hinzufügen, richtig? Nicht wirklich. Im Gegensatz zu Aktivitätsklassen werden Fragmente nicht in der Manifestdatei registriert. Fügen Sie einfach die Aktivitätsklassen zur Manifestdatei hinzu und los geht's.

Hier ist die Beispielmanifestdatei für Ihr Sehvergnügen:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.mamlambo.circlesfragmentexample"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="16" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.mamlambo.circlesfragmentexample.CircleListActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name="com.mamlambo.circlesfragmentexample.CircleDetailActivity"
            android:label="@string/title_circle_detail"
            android:parentActivityName=".CircleListActivity" >
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value=".CircleListActivity" />
        </activity>
    </application>

</manifest>

Beachten Sie die große Auswahl an Android SDK-Versionen, die mit diesem Ansatz mithilfe der Fragmentfunktion der Unterstützungsbibliothek unterstützt werden können.

Schritt 10: Ausführen der App

Obwohl wir der Anwendung nicht den vollständigen Quellcode, der in diesem Lernprogramm eingefügt wurde, und die Ressourcen der Anwendung präsentiert haben, können Sie diese Details selbst eingeben. Oder Sie können den Code herunterladen (siehe Schritt 0), kompilieren und ausführen. Oder Sie können die vorkompilierte Binärdatei herunterladen und installieren.

Wenn Sie jedoch in einer Gerätekonfiguration mit einer Breite von 850 dp oder einem extra großen Bildschirm (mindestens 960 x 640 dp) arbeiten, sehen Sie dieses Bildschirmdesign (ein Bildschirm mit 1920 x 1200 Pixel bei 10 "):

Und wenn die Bildschirmbreite weniger als 850 dp beträgt, kehrt das Layout in den Einzelfenster-Modus zurück, z. B. diese 1280 Pixel breite Telefonanzeige im Querformat:

Oder dieses 768 Pixel breite Porträt-Telefon:

Oder dieses 1200px breite Porträt-Display auf einem Tablet:

Aufgrund der Verwendung abstrahierter Messungen, z. B. der Verwendung von dp-Einheiten, konnten Sie die beiden unterschiedlichen Layouts auf einem Bildschirm mit identischen Pixelauflösungen und unterschiedlichen Pixeldichten anzeigen. Dies hilft zu verhindern, dass die Informationsdichte (mehr Pixel bedeuten nicht immer, dass Ihre Benutzer mehr Daten wünschen) auf physisch kleinen Bildschirmen zu hoch ist, und ist eines der großartigen Dinge am Android-Ressourcensystem.

Abschluss

Sie haben die Grundlagen der Verwendung der Android Fragment API kennengelernt, die in der Android Support-Bibliothek verfügbar ist. Fragmente enthalten zwar viel, viel mehr, aber dieses Tutorial bietet Ihnen einen Ausgangspunkt für einen sehr häufigen Anwendungsfall, der das Erscheinungsbild vieler Anwendungen oder Teile von Anwendungen erheblich verbessern kann, unabhängig davon, mit welcher Android-Version sie ausgeführt werden oder Bildschirme, auf denen sie angezeigt werden.

Über die Autoren

Die mobilen Entwickler Lauren Darcey und Shane Conder haben mehrere Bücher zur Android-Entwicklung gemeinsam verfasst: ein ausführliches Programmierbuch mit dem Titel Android Wireless Application Development (jetzt in der dritten Ausgabe als zweibändiges Set), Sams Teach Yourself Android Application Development in 24 Stunden, und Erlernen der Programmierung von Android-Anwendungen für den Kindle Fire: Eine praktische Anleitung zum Erstellen Ihrer ersten Android-Anwendung. Wenn sie nicht schreiben, verbringen sie ihre Zeit damit, mobile Software in ihrem Unternehmen zu entwickeln und Beratungsdienste anzubieten. Sie können per E-Mail an androidwirelessdev+mt@gmail.com, über ihren Blog unter androidbook.blogspot.com und auf Twitter @androidwireless erreicht werden.