Einführung in diesen Abschnitt:
Dieser Abschnitt setzt sich mit LayoutInflater (Layout-Dienst) fort, einem Systemdienst in Android. Wenn es um Layouts geht, denkt man vielleicht zuerst daran, ein Layout-XML zu schreiben und dann die setContentView()-Methode von Activity aufzurufen, um das Layout zu laden und auf dem Bildschirm anzuzeigen, oder? Tatsächlich läuft es darunter trotzdem über LayoutInflater, der den in Android integrierten Pull-Parser verwendet, um das Layout zu parsen. Er wird im Allgemeinen häufiger beim dynamischen Laden von Layouts oder beim Hinzufügen von Steuerelementen in Android verwendet. In diesem Abschnitt lernen wir einige seiner Verwendungsweisen in der tatsächlichen Entwicklung kennen~
Offizielle API-Dokumentation:LayoutInflater
1. Einführung in LayoutInflater
1) Was zum Teufel ist ein Layout?
Antwort: Er ist ein Systemdienst zum Laden von Layouts, das heißt, er instanziiert View-Objekte, die den Layout-XML-Dateien entsprechen. Er kann nicht direkt verwendet werden; du musst eine an den aktuellen Context gebundene LayoutInflater-Instanz über diegetLayoutInflater( )-Methode odergetSystemService( )-Methode, um eine an den aktuellen Context gebundene LayoutInflater-Instanz zu erhalten!
2) Verwendung von LayoutInflater
① Drei Methoden, um eine LayoutInflater-Instanz zu erhalten:
LayoutInflater inflater1 = LayoutInflater.from(this); LayoutInflater inflater2 = getLayoutInflater(); LayoutInflater inflater3 = (LayoutInflater) getSystemService(LAYOUT_INFLATER_SERVICE);
PS: Tatsächlich laufen die letzten beiden auf der zugrunde liegenden Ebene über die erste Methode~
② Methoden zum Laden von Layouts:
public View inflate(int resource, ViewGroup root, boolean attachToRoot) Die drei Parameter dieser Methode sind in dieser Reihenfolge:
① Die Ressourcen-ID, die dem zu ladenden Layout entspricht
② Bette ein weiteres übergeordnetes Layout außerhalb dieses Layouts ein. Wenn nicht benötigt, schreibe einfach null!
③ Ob die äußerste Ebene der geladenen Layoutdatei mit einem Root-Layout umschlossen werden soll. Wenn dieser Parameter nicht gesetzt ist: Wenn root nicht null ist, ist der Standardwert true Wenn root null ist, hat attachToRoot keine Wirkung! Wenn root nicht null ist und attachToRoot true ist, wird um die äußerste Ebene der geladenen Layoutdatei ein Root-Layout verschachtelt; Wenn false, hat root keine Wirkung! Einfach gesagt:Ob ein äußerer Root-Container für das geladene Layout hinzugefügt werden soll~!
③ Festlegen zugehöriger Attribute durch LayoutInflater.LayoutParams:
Zum Beispiel kann RelativeLayout auch Regeln über die Methode addRule hinzufügen, das heißt, die Position festzulegen: Ist sie relativ zum übergeordneten Container? Oder relativ zu untergeordneten Steuerelementen? Oder Ränder festlegen usw. Es bleibt Ihnen überlassen~
2. Layouts mit reinem Java-Code laden
Wir sind bereits daran gewöhnt, XML zu verwenden, um die benötigten Layouts zu erzeugen, aber in bestimmten Situationen müssen wir Java-Code verwenden, um Komponenten oder Layouts dynamisch zu unseren Layouts hinzuzufügen!
Es wird jedoch nicht empfohlen, Android-Seitenlayouts vollständig mit Java-Code zu schreiben. Erstens entsteht mehr Code, und wenn er lang wird, kann er leicht unübersichtlich werden, und er ist nicht förderlich für die Trennung der Geschäftslogik. Wir empfehlen weiterhin, Layouts mit XML zu erstellen und dann die darin enthaltenen Komponenten über Java-Code zu ändern. Natürlich müssen Sie manchmal Komponenten dynamisch mit Java hinzufügen!
Ablauf des Ladens von Layouts mit reinem Java-Code:
——Schritt 1:
①Einen Container erstellen:LinearLayout ly = new LinearLayout(this);
②Komponenten erstellen:Button btnOne = new Button(this);
——Schritt 2:
Sie können zugehörige Attribute für den Container oder die Komponenten festlegen: Zum Beispiel:LinearLayout, können wir die Anordnungsrichtung der Komponenten festlegen:ly.setOrientation(LinearLayout.VERTICAL);Und Komponenten können ebenfalls: zum Beispiel Button:btnOne.setText("Button1");Für Methoden zum Festlegen von Attributen siehe die Android-API. Normalerweise müssen Sie bei Attributen, die in XML festgelegt werden, nur 'set' davor setzen, zum BeispielsetPadding(left, top, right, bottom);
——Schritt 3:
Fügen Sie die Komponente oder den Container einem Container hinzu. Zu diesem Zeitpunkt müssen wir möglicherweise die Hinzufügungsposition der Komponente festlegen oder ihre Größe festlegen: Wir müssen eine Klasse verwenden: LayoutParams. Wir können sie uns als ein Informationspaket für den Layout-Container vorstellen! Eine Klasse, die Informationen wie Position und Größe kapselt! Zuerst demonstrieren wir die Methode zum Festlegen der Größe: (das LinearLayout davor kann je nach verschiedenen Containern geändert werden)
LinearLayout.LayoutParams lp1 = new LinearLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
Sehr einfach. Als Nächstes kommt das Festlegen der Position. Beim Festlegen der Position betrachten wir normalerweise nur RelativeLayout! Zu diesem Zeitpunkt verwenden Sie die addRule()-Methode von LayoutParams! Sie können mehrere addRule()-Aufrufe hinzufügen! Legen Sie die Position der Komponente im übergeordneten Container fest,
Zum BeispielLegen Sie die Ausrichtungsmethode der Komponente fest:
RelativeLayout rly = new RelativeLayout(this);
RelativeLayout.LayoutParams lp2 = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
lp2.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
Button btnOne = new Button(this);
rly.addView(btnOne, lp2);
Ausrichtung relativ zu anderen Komponenten: (Es gibt einen Nachteil: Sie müssen manuell eine id für die Referenzkomponente festlegen, wasmanuellist!!!!) Zum Beispiel: Nachdem Sie btnOne auf center gesetzt haben, positionieren Sie BtnTwo unter btnOne und rechts vom übergeordneten Container!
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
RelativeLayout rly = new RelativeLayout(this);
Button btnOne = new Button(this);
btnOne.setText("按钮1");
Button btnTwo = new Button(this);
btnTwo.setText("按钮2");
// 为按钮1设置一个id值
btnOne.setId(123);
// 设置按钮1的位置,在父容器中居中
RelativeLayout.LayoutParams rlp1 = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
rlp1.addRule(RelativeLayout.CENTER_IN_PARENT);
// 设置按钮2的位置,在按钮1的下方,并且对齐父容器右面
RelativeLayout.LayoutParams rlp2 = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
rlp2.addRule(RelativeLayout.BELOW, 123);
rlp2.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
// 将组件添加到外部容器中
rly.addView(btnTwo, rlp2);
rly.addView(btnOne, rlp1);
// 设置当前视图加载的View即rly
setContentView(rly);
}
}
——Schritt 4:
Rufen Sie einfach die Methode setContentView() auf, um das Layout-Objekt zu laden! Wenn Sie außerdem eine View aus einem Container entfernen möchten, können Sie die MethoderemoveView(zu entfernende Komponente) des Containers aufrufen;
Screenshot der Ausführung:

3. Dynamisches Hinzufügen von Steuerelementen oder XML-Layouts mit Java-Code
Im zweiten Punkt haben wir erläutert, wie Layouts mit reinem Java-Code geladen werden. In der Praxis wird das nicht oft verwendet; häufiger geht es darum, View-Steuerelemente dynamisch hinzuzufügen und XML-Layouts dynamisch zu laden!
1) Dynamisches Hinzufügen von Views mit Java-Code
Es gibt zwei Möglichkeiten, Komponenten dynamisch hinzuzufügen. Der Unterschied besteht darin, ob Sie zuerst ;setContentView(R.layout.activity_main)aufrufen müssen. Nachfolgend wird das Hinzufügen eines Buttons mit den beiden unterschiedlichen Ansätzen demonstriert:
Schreiben Sie zuerst eine Layoutdatei:activity_main.xml:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/RelativeLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<TextView
android:id="@+id/txtTitle"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="我是xml文件加载的布局"/>
</RelativeLayout>
Der erste Ansatz: Es ist nicht nötig, setContentView() zuerst aufzurufen, um die Layoutdatei zu laden:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Button btnOne = new Button(this);
btnOne.setText("我是动态添加的按钮");
RelativeLayout.LayoutParams lp2 = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
lp2.addRule(RelativeLayout.CENTER_IN_PARENT);
LayoutInflater inflater = LayoutInflater.from(this);
RelativeLayout rly = (RelativeLayout) inflater.inflate(
R.layout.activity_main, null)
.findViewById(R.id.RelativeLayout1);
rly.addView(btnOne,lp2);
setContentView(rly);
}
}
Der zweite Ansatz: Es ist nicht nötig, setContentView() zuerst aufzurufen, um die Layoutdatei zu laden:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btnOne = new Button(this);
btnOne.setText("我是动态添加的按钮");
RelativeLayout.LayoutParams lp2 = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
lp2.addRule(RelativeLayout.CENTER_IN_PARENT);
RelativeLayout rly = (RelativeLayout) findViewById(R.id.RelativeLayout1);
rly.addView(btnOne,lp2);
}
}
Analyse und Zusammenfassung:
Der Code ist sehr einfach. Nachdem wir den Button erstellt haben, haben wir außerdem ein LayoutParams-Objekt erstellt, um die Größe des Buttons festzulegen, und die Position des Buttons über die addRule()-Methode festgelegt!
Der erste Ansatz: Lade das activity_main-Layout über die inflate()-Methode von LayoutInflater, hole den äußeren Container, dann addView, um den Button in den Container einzufügen, und schließlich setContentView();
Der zweite Ansatz: Da wir das Layout bereits über die setContentView()-Methode geladen haben, können wir an diesem Punkt findViewById verwenden, um den äußeren Container zu finden, dann addView, und schließlich setContentView()!
Darüber hinaus ist der View-Knoten, den setContentView() setzt, der Wurzelknoten des gesamten XML!
2) XML-Layouts mit Java-Code dynamisch laden
Als Nächstes versuchen wir etwas anderes. Dieses Mal wird eine XML-Datei geladen!Eine XML-Datei dynamisch hinzufügen !Schreiben Sie zuerst die Haupt-Layoutdatei und die dynamisch geladene Layoutdatei:
activity_main.xml:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/RelativeLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<Button
android:id="@+id/btnLoad"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="动态加载布局"/>
</RelativeLayout>
inflate.xml:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical"
android:id="@+id/ly_inflate" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="我是Java代码加载的布局" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="我是布局里的一个小按钮" />
</LinearLayout>
Dann gehen Sie zu unsererMainActivity.javaLaden Sie das XML-Layout hier dynamisch:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//获得LayoutInflater对象;
final LayoutInflater inflater = LayoutInflater.from(this);
//获得外部容器对象
final RelativeLayout rly = (RelativeLayout) findViewById(R.id.RelativeLayout1);
Button btnLoad = (Button) findViewById(R.id.btnLoad);
btnLoad.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//加载要添加的布局对象
LinearLayout ly = (LinearLayout) inflater.inflate(
R.layout.inflate, null, false).findViewById(
R.id.ly_inflate);
//设置加载布局的大小与位置
RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
lp.addRule(RelativeLayout.CENTER_IN_PARENT);
rly.addView(ly,lp);
}
});
}
}
Screenshot der Ausführung:

Codeanalyse:
① Das Container-Objekt abrufen:
final RelativeLayout rly = (RelativeLayout) findViewById(R.id.RelativeLayout1);② Das Inflater-Objekt abrufen, das XML des hinzugefügten Layouts laden und findViewById verwenden, um den äußersten Wurzelknoten zu finden
final LayoutInflater inflater = LayoutInflater.from(this); LinearLayout ly = (LinearLayout) inflater.inflate(R.layout.inflate, null, false) .findViewById(R.id.ly_inflate);③ Größen- und Positionsinformationen für diesen Container festlegen:
RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams( LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); lp.addRule(RelativeLayout.CENTER_IN_PARENT);④ Füge es dem äußeren Container hinzu:
rly.addView(ly,lp);
4. Quellcode der inflate()-Methode von LayoutInflater
Zum Schluss ist hier der Quellcode der inflate()-Methode von LayoutInflater. Wenn du interessiert bist, kannst du einen Blick hineinwerfen~ Es ist eigentlich nur Pull-Parsing~
public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
synchronized (mConstructorArgs) {
final AttributeSet attrs = Xml.asAttributeSet(parser);
mConstructorArgs[0] = mContext;
View result = root;
try {
int type;
while ((type = parser.next()) != XmlPullParser.START_TAG &&
type != XmlPullParser.END_DOCUMENT) {
}
if (type != XmlPullParser.START_TAG) {
throw new InflateException(parser.getPositionDescription()
+ ": No start tag found!");
}
final String name = parser.getName();
if (TAG_MERGE.equals(name)) {
if (root == null || !attachToRoot) {
throw new InflateException("merge can be used only with a valid "
+ "ViewGroup root and attachToRoot=true");
}
rInflate(parser, root, attrs);
} else {
View temp = createViewFromTag(name, attrs);
ViewGroup.LayoutParams params = null;
if (root != null) {
params = root.generateLayoutParams(attrs);
if (!attachToRoot) {
temp.setLayoutParams(params);
}
}
rInflate(parser, temp, attrs);
if (root != null && attachToRoot) {
root.addView(temp, params);
}
if (root == null || !attachToRoot) {
result = temp;
}
}
} catch (XmlPullParserException e) {
InflateException ex = new InflateException(e.getMessage());
ex.initCause(e);
throw ex;
} catch (IOException e) {
InflateException ex = new InflateException(
parser.getPositionDescription()
+ ": " + e.getMessage());
ex.initCause(e);
throw ex;
}
return result;
}
}
Zusammenfassung dieses Abschnitts:
In diesem Abschnitt haben wir LayoutInflater (Layout-Dienst) in Android erklärt, sowie Dinge, die mit dem dynamischen Laden von Views und Steuerelementen zusammenhängen. Ich glaube, das wird Freunden hilfreich sein, die neu bei Steuerelementen sind. In Ordnung, das war alles für diesen Abschnitt, danke~
